module Hydra.Impl.Haskell.Sources.Ext.Scala.Meta where

import Hydra.Impl.Haskell.Sources.Core

import Hydra.All
import Hydra.Impl.Haskell.Dsl.Types as Types
import Hydra.Impl.Haskell.Dsl.Standard


scalaMetaModule :: Module Meta
scalaMetaModule :: Module Meta
scalaMetaModule = forall m.
Namespace -> [Element m] -> [Module m] -> Maybe String -> Module m
Module Namespace
ns forall {m}. [Element m]
elements [] forall a b. (a -> b) -> a -> b
$
    forall a. a -> Maybe a
Just String
"A Scala syntax model based on Scalameta (https://scalameta.org)"
  where
    ns :: Namespace
ns = String -> Namespace
Namespace String
"hydra/ext/scala/meta"
    def :: String -> Type m -> Element m
def = forall m. Namespace -> String -> Type m -> Element m
datatype Namespace
ns
    meta :: String -> Type m
meta = forall m. Namespace -> String -> Type m
nsref Namespace
ns

    elements :: [Element m]
elements = [

      forall {m}. String -> Type m -> Element m
def String
"PredefString" --  See scala/Predef.scala
        forall m. Type m
string,

      forall {m}. String -> Type m -> Element m
def String
"ScalaSymbol" forall a b. (a -> b) -> a -> b
$ --  See scala/Symbol.scala
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall m. Type m
string],

--  scala/meta/Trees.scala source below this line. Hydra type definitions inline

-- package scala.meta
--
-- import org.scalameta.invariants._
-- import scala.meta.classifiers._
-- import scala.meta.inputs._
-- import scala.meta.tokens._
-- import scala.meta.prettyprinters._
-- import scala.meta.internal.trees._
-- import scala.meta.internal.trees.Metadata.binaryCompatField
-- @root trait Tree extends InternalTree {
      forall {m}. String -> Type m -> Element m
def String
"Tree" forall a b. (a -> b) -> a -> b
$ --  Note: ignoring fields of Tree and InternalTree for now
        forall m. [FieldType m] -> Type m
union [
          String
"ref"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ref",
          String
"stat"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Stat",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"bounds"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Bounds",
          String
"pat"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"member"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Member",
          String
"ctor"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ctor",
          String
"template"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Template",
          String
"mod"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Mod",
          String
"enumerator"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Enumerator",
          String
"importer"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Importer",
          String
"importee"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Importee",
          String
"caseTree"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"CaseTree",
          String
"source"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Source",
          String
"quasi"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Quasi"],
--   def parent: Option[Tree]
--   def children: List[Tree]
--
--   def pos: Position
--   def tokens(implicit dialect: Dialect): Tokens
--
--   final override def canEqual(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
--   final override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
--   final override def hashCode: Int = System.identityHashCode(this)
--   final override def toString = scala.meta.internal.prettyprinters.TreeToString(this)
-- }
--
-- object Tree extends InternalTreeXtensions {
--   implicit def classifiable[T <: Tree]: Classifiable[T] = null
--   implicit def showStructure[T <: Tree]: Structure[T] =
--     scala.meta.internal.prettyprinters.TreeStructure.apply[T]
--   implicit def showSyntax[T <: Tree](implicit dialect: Dialect): Syntax[T] =
--     scala.meta.internal.prettyprinters.TreeSyntax.apply[T](dialect)
-- }
--
-- @branch trait Ref extends Tree
      forall {m}. String -> Type m -> Element m
def String
"Ref" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
          String
"init"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Init"],
-- @branch trait Stat extends Tree
      forall {m}. String -> Type m -> Element m
def String
"Stat" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"term"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"decl"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Decl",
          String
"defn"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn",
          String
"importExport"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"ImportExportStat"],
--
-- @branch trait Name extends Ref { def value: String }
      forall {m}. String -> Type m -> Element m
def String
"Name" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"value"forall m. String -> Type m -> FieldType m
>: forall m. Type m
string,
          String
"anonymous"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"indeterminate"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"PredefString"],
-- object Name {
--   def apply(value: String): Name = if (value == "") Name.Anonymous() else Name.Indeterminate(value)
--   def unapply(name: Name): Option[String] = Some(name.value)
--   @ast class Anonymous() extends Name {
--     def value = ""
--     checkParent(ParentChecks.NameAnonymous)
--   }
--   @ast class Indeterminate(value: Predef.String @nonEmpty) extends Name
-- }
--
-- @branch trait Lit extends Data with Pat with Type {
      forall {m}. String -> Type m -> Element m
def String
"Lit" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
--   def value: Any
-- }
-- object Lit {
--   def unapply(arg: Lit): Option[Any] = Some(arg.value)
--   @ast class Null() extends Lit { def value: Any = null }
          String
"null"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
--   @ast class Int(value: scala.Int) extends Lit
          String
"int"forall m. String -> Type m -> FieldType m
>: forall m. Type m
int32,
--   // NOTE: Lit.Double/Float are strings to work the same across JS/JVM. Example:
--   // 1.4f.toString == "1.399999976158142" // in JS
--   // 1.4f.toString == "1.4"               // in JVM
--   // See https://www.scala-js.org/doc/semantics.html-- tostring-of-float-double-and-unit
--   @ast class Double(format: scala.Predef.String) extends Lit { val value = format.toDouble }
          String
"double"forall m. String -> Type m -> FieldType m
>: forall m. Type m
float64,
--   object Double { def apply(double: scala.Double): Double = Lit.Double(double.toString) }
--   @ast class Float(format: scala.Predef.String) extends Lit { val value = format.toFloat }
          String
"float"forall m. String -> Type m -> FieldType m
>: forall m. Type m
float32,
--   object Float { def apply(float: scala.Float): Float = Lit.Float(float.toString) }
--   @ast class Byte(value: scala.Byte) extends Lit
          String
"byte"forall m. String -> Type m -> FieldType m
>: forall m. Type m
int8,
--   @ast class Short(value: scala.Short) extends Lit
          String
"short"forall m. String -> Type m -> FieldType m
>: forall m. Type m
int16,
--   @ast class Char(value: scala.Char) extends Lit
          String
"char"forall m. String -> Type m -> FieldType m
>: forall m. Type m
uint16,
--   @ast class Long(value: scala.Long) extends Lit
          String
"long"forall m. String -> Type m -> FieldType m
>: forall m. Type m
int64,
--   @ast class Boolean(value: scala.Boolean) extends Lit
          String
"boolean"forall m. String -> Type m -> FieldType m
>: forall m. Type m
boolean,
--   @ast class Unit() extends Lit { def value: Any = () }
          String
"unit"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
--   @ast class String(value: scala.Predef.String) extends Lit
          String
"string"forall m. String -> Type m -> FieldType m
>: forall m. Type m
string,
--   @ast class Symbol(value: scala.Symbol) extends Lit
          String
"symbol"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"ScalaSymbol"],
-- }
--
-- @branch trait Data extends Stat
      forall {m}. String -> Type m -> Element m
def String
"Data" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"lit"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Lit",
          String
"ref"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Ref",
          String
"interpolate"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Interpolate",
          String
"xml"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Xml",
          String
"apply"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Apply",
          String
"applyUsing"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.ApplyUsing",
          String
"applyType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.ApplyType",
          String
"assign"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Assign",
          String
"return"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Return",
          String
"throw"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Throw",
          String
"ascribe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Ascribe",
          String
"annotate"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Annotate",
          String
"tuple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Tuple",
          String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Block",
          String
"endMarker"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.EndMarker",
          String
"if"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.If",
          String
"quotedMacroExpr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.QuotedMacroExpr",
          String
"quotedMacroType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.QuotedMacroType",
          String
"splicedMacroExpr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.SplicedMacroExpr",
          String
"match"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Match",
          String
"try"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Try",
          String
"tryWithHandler"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.TryWithHandler",
          String
"functionData"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.FunctionData",
          String
"polyFunction"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.PolyFunction",
          String
"partialFunction"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.PartialFunction",
          String
"while"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.While",
          String
"do"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Do",
          String
"for"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.For",
          String
"forYield"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.ForYield",
          String
"new"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.New",
          String
"newAnonymous"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.NewAnonymous",
          String
"placeholder"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Placeholder",
          String
"eta"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Eta",
          String
"repeated"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Repeated",
          String
"param"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Param"],
-- object Data {
--   @branch trait Ref extends Data with scala.meta.Ref
      forall {m}. String -> Type m -> Element m
def String
"Data.Ref" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"this"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.This",
          String
"super"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Super",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
          String
"anonymous"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Anonymous",
          String
"select"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Select",
          String
"applyUnary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.ApplyUnary"],
--   @ast class This(qual: scala.meta.Name) extends Data.Ref
      forall {m}. String -> Type m -> Element m
def String
"Data.This"
        forall m. Type m
unit,
--   @ast class Super(thisp: scala.meta.Name, superp: scala.meta.Name) extends Data.Ref
      forall {m}. String -> Type m -> Element m
def String
"Data.Super" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"thisp"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
          String
"superp"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name"],
--   @ast class Name(value: Predef.String @nonEmpty) extends scala.meta.Name with Data.Ref with Pat
      forall {m}. String -> Type m -> Element m
def String
"Data.Name" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"value"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"PredefString"],
--   @ast class Anonymous() extends scala.meta.Name with Data.Ref {
      forall {m}. String -> Type m -> Element m
def String
"Data.Anonymous"
        forall m. Type m
unit,
--     def value = ""
--     checkParent(ParentChecks.AnonymousImport)
--   }
--   @ast class Select(qual: Data, name: Data.Name) extends Data.Ref with Pat
      forall {m}. String -> Type m -> Element m
def String
"Data.Select" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"qual"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name"],
--   @ast class Interpolate(prefix: Name, parts: List[Lit] @nonEmpty, args: List[Data]) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.Interpolate" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"prefix"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
          String
"parts"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Lit",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--     checkFields(parts.length == args.length + 1)
--   }
--   @ast class Xml(parts: List[Lit] @nonEmpty, args: List[Data]) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.Xml" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"parts"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Lit",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--     checkFields(parts.length == args.length + 1)
--   }
--   @ast class Apply(fun: Data, args: List[Data]) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Apply" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"fun"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--   @ast class ApplyUsing(fun: Data, args: List[Data]) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.ApplyUsing" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"fun"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"targs"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--   @ast class ApplyType(fun: Data, targs: List[Type] @nonEmpty) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.ApplyType" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"op"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
          String
"targs"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--   @ast class ApplyInfix(lhs: Data, op: Name, targs: List[Type], args: List[Data]) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.ApplyInfix" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"op"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
          String
"targs"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--   @ast class ApplyUnary(op: Name, arg: Data) extends Data.Ref {
      forall {m}. String -> Type m -> Element m
def String
"Data.ApplyUnary" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"op"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
          String
"arg"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--     checkFields(op.isUnaryOp)
--   }
--   @ast class Assign(lhs: Data, rhs: Data) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.Assign" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--     checkFields(lhs.is[Data.Quasi] || lhs.is[Data.Ref] || lhs.is[Data.Apply])
--     checkParent(ParentChecks.DataAssign)
--   }
--   @ast class Return(expr: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Return" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class Throw(expr: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Throw" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class Ascribe(expr: Data, tpe: Type) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Ascribe" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class Annotate(expr: Data, annots: List[Mod.Annot] @nonEmpty) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Annotate" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"annots"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod.Annot"],
--   @ast class Tuple(args: List[Data] @nonEmpty) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.Tuple" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--     // tuple must have more than one element
--     // however, this element may be Quasi with "hidden" list of elements inside
--     checkFields(args.length > 1 || (args.length == 1 && args.head.is[Data.Quasi]))
--   }
--   @ast class Block(stats: List[Stat]) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.Block" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"stats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Stat"],
--     // extension group block can have declarations without body too
--     checkFields(stats.forall(st => st.isBlockStat || st.is[Decl]))
--   }
--   @ast class EndMarker(name: Data.Name) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.EndMarker" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name"],
--   @ast class If(cond: Data, thenp: Data, elsep: Data) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.If" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"thenp"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"elsep"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--     @binaryCompatField(since = "4.4.0")
--     private var _mods: List[Mod] = Nil
--   }
--   @ast class QuotedMacroExpr(body: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.QuotedMacroExpr" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class QuotedMacroType(tpe: Type) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.QuotedMacroType" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class SplicedMacroExpr(body: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.SplicedMacroExpr" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class Match(expr: Data, cases: List[Case] @nonEmpty) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.Match" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"cases"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Case"],
--     @binaryCompatField(since = "4.4.5")
--     private var _mods: List[Mod] = Nil
--   }
--   @ast class Try(expr: Data, catchp: List[Case], finallyp: Option[Data]) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Try" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"catchp"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Case",
          String
"finallyp"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--   @ast class TryWithHandler(expr: Data, catchp: Data, finallyp: Option[Data]) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.TryWithHandler" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"catchp"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"finallyp"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--
--   @branch trait FunctionData extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.FunctionData" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"contextFunction"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.ContextFunction",
          String
"function"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Function"],
--     def params: List[Data.Param]
--     def body: Data
--   }
--   @ast class ContextFunction(params: List[Data.Param], body: Data) extends FunctionData {
      forall {m}. String -> Type m -> Element m
def String
"Data.ContextFunction" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"params"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--     checkFields(
--       params.forall(param =>
--         param.is[Data.Param.Quasi] ||
--           (param.name.is[scala.meta.Name.Anonymous] ==> param.default.isEmpty)
--       )
--     )
--   }
--   @ast class Function(params: List[Data.Param], body: Data) extends FunctionData {
      forall {m}. String -> Type m -> Element m
def String
"Data.Function" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"params"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--     checkFields(
--       params.forall(param =>
--         param.is[Data.Param.Quasi] ||
--           (param.name.is[scala.meta.Name.Anonymous] ==> param.default.isEmpty)
--       )
--     )
--     checkFields(
--       params.exists(_.is[Data.Param.Quasi]) ||
--         params.exists(_.mods.exists(_.is[Mod.Implicit])) ==> (params.length == 1)
--     )
--   }
--   @ast class PolyFunction(tparams: List[Type.Param], body: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.PolyFunction" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class PartialFunction(cases: List[Case] @nonEmpty) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.PartialFunction" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"cases"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Case"],
--   @ast class While(expr: Data, body: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.While" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class Do(body: Data, expr: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Do" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class For(enums: List[Enumerator] @nonEmpty, body: Data) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.For" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"enums"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Enumerator"],
--     checkFields(
--       enums.head.is[Enumerator.Generator] || enums.head.is[Enumerator.CaseGenerator] || enums.head
--         .is[Enumerator.Quasi]
--     )
--   }
--   @ast class ForYield(enums: List[Enumerator] @nonEmpty, body: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.ForYield" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"enums"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Enumerator"],
--   @ast class New(init: Init) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.New" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"init"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Init"],
--   @ast class NewAnonymous(templ: Template) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.NewAnonymous" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"templ"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Template"],
--   @ast class Placeholder() extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Placeholder"
        forall m. Type m
unit,
--   @ast class Eta(expr: Data) extends Data
      forall {m}. String -> Type m -> Element m
def String
"Data.Eta" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class Repeated(expr: Data) extends Data {
      forall {m}. String -> Type m -> Element m
def String
"Data.Repeated" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"expr"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--     checkParent(ParentChecks.DataRepeated)
--   }
--   @ast class Param(mods: List[Mod], name: meta.Name, decltpe: Option[Type], default: Option[Data])
--       extends Member
      forall {m}. String -> Type m -> Element m
def String
"Data.Param" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
          String
"default"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--   def fresh(): Data.Name = fresh("fresh")
--   def fresh(prefix: String): Data.Name = Data.Name(prefix + Fresh.nextId())
-- }
--
-- @branch trait Type extends Tree
      forall {m}. String -> Type m -> Element m
def String
"Type" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"ref"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Ref",
          String
"anonymousName"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.AnonymousName",
          String
"apply"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Apply",
          String
"applyInfix"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.ApplyInfix",
          String
"functionType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.FunctionType",
          String
"polyFunction"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.PolyFunction",
          String
"implicitFunction"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.ImplicitFunction",
          String
"tuple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Tuple",
          String
"with"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.With",
          String
"and"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.And",
          String
"or"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Or",
          String
"refine"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Refine",
          String
"existential"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Existential",
          String
"annotate"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Annotate",
          String
"lambda"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Lambda",
          String
"macro"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Macro",
          String
"method"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Method",
          String
"placeholder"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Placeholder",
          String
"byName"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.ByName",
          String
"repeated"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Repeated",
          String
"var"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Var",
          String
"typedParam"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.TypedParam",
          String
"match"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Match"],
-- object Type {
--   @branch trait Ref extends Type with scala.meta.Ref
      forall {m}. String -> Type m -> Element m
def String
"Type.Ref" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name",
          String
"select"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Select",
          String
"project"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Project",
          String
"singleton"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Singleton"],
--   @ast class Name(value: String @nonEmpty) extends scala.meta.Name with Type.Ref
      forall {m}. String -> Type m -> Element m
def String
"Type.Name" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"value"forall m. String -> Type m -> FieldType m
>: forall m. Type m
string],
--   @ast class AnonymousName() extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.AnonymousName"
        forall m. Type m
unit,
--   @ast class Select(qual: Data.Ref, name: Type.Name) extends Type.Ref {
      forall {m}. String -> Type m -> Element m
def String
"Type.Select" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"qual"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Ref",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name"],
--     checkFields(qual.isPath || qual.is[Data.Super] || qual.is[Data.Ref.Quasi])
--   }
--   @ast class Project(qual: Type, name: Type.Name) extends Type.Ref
      forall {m}. String -> Type m -> Element m
def String
"Type.Project" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"qual"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name"],
--   @ast class Singleton(ref: Data.Ref) extends Type.Ref {
      forall {m}. String -> Type m -> Element m
def String
"Type.Singleton" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"ref"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Ref"],
--     checkFields(ref.isPath || ref.is[Data.Super])
--   }
--   @ast class Apply(tpe: Type, args: List[Type] @nonEmpty) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.Apply" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type"],
--   @ast class ApplyInfix(lhs: Type, op: Name, rhs: Type) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.ApplyInfix" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"op"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @branch trait FunctionType extends Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.FunctionType" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"function"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Function",
          String
"contextFunction"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.ContextFunction"],
--     def params: List[Type]
--     def res: Type
--   }
--   @ast class Function(params: List[Type], res: Type) extends FunctionType
      forall {m}. String -> Type m -> Element m
def String
"Type.Function" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"params"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
          String
"res"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class PolyFunction(tparams: List[Type.Param], tpe: Type) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.PolyFunction" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class ContextFunction(params: List[Type], res: Type) extends FunctionType
      forall {m}. String -> Type m -> Element m
def String
"Type.ContextFunction" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"params"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
          String
"res"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast @deprecated("Implicit functions are not supported in any dialect")
--   class ImplicitFunction(
      forall {m}. String -> Type m -> Element m
def String
"Type.ImplicitFunction" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       params: List[Type],
          String
"params"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
--       res: Type
          String
"res"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   ) extends Type
--   @ast class Tuple(args: List[Type] @nonEmpty) extends Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.Tuple" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type"],
--     checkFields(args.length > 1 || (args.length == 1 && args.head.is[Type.Quasi]))
--   }
--   @ast class With(lhs: Type, rhs: Type) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.With" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class And(lhs: Type, rhs: Type) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.And" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class Or(lhs: Type, rhs: Type) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.Or" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class Refine(tpe: Option[Type], stats: List[Stat]) extends Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.Refine" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
          String
"stats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Stat"],
--     checkFields(stats.forall(_.isRefineStat))
--   }
--   @ast class Existential(tpe: Type, stats: List[Stat] @nonEmpty) extends Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.Existential" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"stats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Stat"],
--     checkFields(stats.forall(_.isExistentialStat))
--   }
--   @ast class Annotate(tpe: Type, annots: List[Mod.Annot] @nonEmpty) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.Annotate" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"annots"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod.Annot"],
--   @ast class Lambda(tparams: List[Type.Param], tpe: Type) extends Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.Lambda" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--     checkParent(ParentChecks.LambdaType)
--   }
--   @ast class Macro(body: Data) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.Macro" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @deprecated("Method type syntax is no longer supported in any dialect", "4.4.3")
--   @ast class Method(paramss: List[List[Data.Param]], tpe: Type) extends Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.Method" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"paramss"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--     checkParent(ParentChecks.TypeMethod)
--   }
--   @ast class Placeholder(bounds: Bounds) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.Placeholder" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"bounds"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Bounds"],
--   @ast class Bounds(lo: Option[Type], hi: Option[Type]) extends Tree
      forall {m}. String -> Type m -> Element m
def String
"Type.Bounds" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lo"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
          String
"hi"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type"],
--   @ast class ByName(tpe: Type) extends Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.ByName" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--     checkParent(ParentChecks.TypeByName)
--   }
--   @ast class Repeated(tpe: Type) extends Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.Repeated" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--     checkParent(ParentChecks.TypeRepeated)
--   }
--   @ast class Var(name: Name) extends Type with Member.Type {
      forall {m}. String -> Type m -> Element m
def String
"Type.Var" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name"],
--     checkFields(name.value(0).isLower)
--     checkParent(ParentChecks.TypeVar)
--   }
--
--   @ast class TypedParam(name: Name, typ: Type) extends Type with Member.Type
      forall {m}. String -> Type m -> Element m
def String
"Type.TypedParam" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
          String
"typ"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class Param(
      forall {m}. String -> Type m -> Element m
def String
"Type.Param" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: meta.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
--       tparams: List[Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       tbounds: Type.Bounds,
          String
"tbounds"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Bounds",
--       vbounds: List[Type],
          String
"vbounds"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
--       cbounds: List[Type]
          String
"cbounds"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type"],
--   ) extends Member
--
--   @ast class Match(tpe: Type, cases: List[TypeCase] @nonEmpty) extends Type
      forall {m}. String -> Type m -> Element m
def String
"Type.Match" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"cases"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"TypeCase"],
--   def fresh(): Type.Name = fresh("fresh")
--   def fresh(prefix: String): Type.Name = Type.Name(prefix + Fresh.nextId())
-- }
--
-- @branch trait Pat extends Tree
      forall {m}. String -> Type m -> Element m
def String
"Pat" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"var"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Var",
          String
"wildcard"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"seqWildcard"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"bind"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Bind",
          String
"alternative"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Alternative",
          String
"tuple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Tuple",
          String
"repeated"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Repeated",
          String
"extract"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Extract",
          String
"extractInfix"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.ExtractInfix",
          String
"interpolate"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Interpolate",
          String
"xml"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Xml",
          String
"typed"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Typed",
          String
"macro"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Macro",
          String
"given"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat.Given"],
-- object Pat {
--   @ast class Var(name: scala.meta.Data.Name) extends Pat with Member.Data { @
      forall {m}. String -> Type m -> Element m
def String
"Pat.Var" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name"],
--     // NOTE: can't do this check here because of things like `val X = 2`
--     // checkFields(name.value(0).isLower)
--     checkParent(ParentChecks.PatVar)
--   }
--   @ast class Wildcard() extends Pat
--   @ast class SeqWildcard() extends Pat {
--     checkParent(ParentChecks.PatSeqWildcard)
--   }
--   @ast class Bind(lhs: Pat, rhs: Pat) extends Pat {
      forall {m}. String -> Type m -> Element m
def String
"Pat.Bind" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat"],
--     checkFields(lhs.is[Pat.Var] || lhs.is[Pat.Quasi])
--   }
--   @ast class Alternative(lhs: Pat, rhs: Pat) extends Pat
      forall {m}. String -> Type m -> Element m
def String
"Pat.Alternative" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat"],
--   @ast class Tuple(args: List[Pat] @nonEmpty) extends Pat {
      forall {m}. String -> Type m -> Element m
def String
"Pat.Tuple" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Pat"],
--     checkFields(args.length > 1 || (args.length == 1 && args.head.is[Pat.Quasi]))
--   }
--   @ast class Repeated(name: scala.meta.Data.Name) extends Pat
      forall {m}. String -> Type m -> Element m
def String
"Pat.Repeated" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name"],
--   @ast class Extract(fun: Data, args: List[Pat]) extends Pat {
      forall {m}. String -> Type m -> Element m
def String
"Pat.Extract" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"fun"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Pat"],
--     checkFields(fun.isExtractor)
--   }
--   @ast class ExtractInfix(lhs: Pat, op: Data.Name, rhs: List[Pat]) extends Pat
      forall {m}. String -> Type m -> Element m
def String
"Pat.ExtractInfix" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"op"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Pat"],
--   @ast class Interpolate(prefix: Data.Name, parts: List[Lit] @nonEmpty, args: List[Pat])
      forall {m}. String -> Type m -> Element m
def String
"Pat.Interpolate" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"prefix"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
          String
"parts"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Lit"],
--       extends Pat {
--     checkFields(parts.length == args.length + 1)
--   }
--   @ast class Xml(parts: List[Lit] @nonEmpty, args: List[Pat]) extends Pat {
      forall {m}. String -> Type m -> Element m
def String
"Pat.Xml" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"parts"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Lit",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Pat"],
--     checkFields(parts.length == args.length + 1)
--   }
--   @ast class Typed(lhs: Pat, rhs: Type) extends Pat {
      forall {m}. String -> Type m -> Element m
def String
"Pat.Typed" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--     checkFields(!rhs.is[Type.Var] && !rhs.is[Type.Placeholder])
--   }
--   @ast class Macro(body: Data) extends Pat {
      forall {m}. String -> Type m -> Element m
def String
"Pat.Macro" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--     checkFields(body.is[Data.QuotedMacroExpr] || body.is[Data.QuotedMacroType])
--   }
--   @ast class Given(tpe: Type) extends Pat
      forall {m}. String -> Type m -> Element m
def String
"Pat.Given" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   def fresh(): Pat.Var = Pat.Var(Data.fresh())
--   def fresh(prefix: String): Pat.Var = Pat.Var(Data.fresh(prefix))
-- }
--
-- @branch trait Member extends Tree {
      forall {m}. String -> Type m -> Element m
def String
"Member" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"term"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Member.Data",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Member.Type",
          String
"termParam"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Param",
          String
"typeParam"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Param",
          String
"self"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Self"],
--   def name: Name
-- }
-- object Member {
--   @branch trait Data extends Member {
      forall {m}. String -> Type m -> Element m
def String
"Member.Data" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"pkg"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pkg",
          String
"object"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pkg.Object"],
--     def name: scala.meta.Data.Name
--   }
--   @branch trait Type extends Member {
      forall {m}. String -> Type m -> Element m
def String
"Member.Type" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--     def name: scala.meta.Type.Name
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name"],
--   }
-- }
--
-- @branch trait Decl extends Stat
      forall {m}. String -> Type m -> Element m
def String
"Decl" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"val"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Decl.Val",
          String
"var"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Decl.Var",
          String
"def"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Decl.Def",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Decl.Type",
          String
"given"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Decl.Given"],
-- object Decl {
--   @ast class Val(mods: List[Mod], pats: List[Pat] @nonEmpty, decltpe: scala.meta.Type) extends Decl
      forall {m}. String -> Type m -> Element m
def String
"Decl.Val" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
          String
"pats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Pat",
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class Var(mods: List[Mod], pats: List[Pat] @nonEmpty, decltpe: scala.meta.Type) extends Decl
      forall {m}. String -> Type m -> Element m
def String
"Decl.Var" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
          String
"pats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Pat",
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class Def(
      forall {m}. String -> Type m -> Element m
def String
"Decl.Def" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: Data.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       paramss: List[List[Data.Param]],
          String
"paramss"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
--       decltpe: scala.meta.Type
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   ) extends Decl with Member.Data @
      --   @ast class Type(
      forall {m}. String -> Type m -> Element m
def String
"Decl.Type" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: scala.meta.Type.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       bounds: scala.meta.Type.Bounds
          String
"bounds"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Bounds"],
--   ) extends Decl with Member.Type
--   @ast class Given(
      forall {m}. String -> Type m -> Element m
def String
"Decl.Given" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: Data.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       sparams: List[List[Data.Param]],
          String
"sparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
--       decltpe: scala.meta.Type
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   ) extends Decl with Member.Data @
-- }
--
-- @branch trait Defn extends Stat
      forall {m}. String -> Type m -> Element m
def String
"Defn" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"val"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Val",
          String
"var"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Var",
          String
"given"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Given",
          String
"enum"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Enum",
          String
"enumCase"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.EnumCase",
          String
"repeatedEnumCase"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.RepeatedEnumCase",
          String
"givenAlias"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.GivenAlias",
          String
"extensionGroup"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.ExtensionGroup",
          String
"def"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Def",
          String
"macro"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Macro",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Type",
          String
"class"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Class",
          String
"trait"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Trait",
          String
"object"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Defn.Object"],
-- object Defn {
--   @ast class Val(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Val" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       pats: List[Pat] @nonEmpty,
          String
"pats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Pat",
--       decltpe: Option[scala.meta.Type],
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
--       rhs: Data
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   ) extends Defn {
--     checkFields(pats.forall(!_.is[Data.Name]))
--   }
--   @ast class Var(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Var" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       pats: List[Pat] @nonEmpty,
          String
"pats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Pat",
--       decltpe: Option[scala.meta.Type],
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
--       rhs: Option[Data]
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--   ) extends Defn {
--     checkFields(pats.forall(!_.is[Data.Name]))
--     checkFields(decltpe.nonEmpty || rhs.nonEmpty)
--     checkFields(rhs.isEmpty ==> pats.forall(_.is[Pat.Var]))
--   }
--   @ast class Given(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Given" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: scala.meta.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       sparams: List[List[Data.Param]],
          String
"sparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
--       templ: Template
          String
"templ"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Template"],
--   ) extends Defn
--   @ast class Enum(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Enum" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: scala.meta.Type.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       ctor: Ctor.Primary,
          String
"ctor"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ctor.Primary",
--       templ: Template
          String
"template"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Template"],
--   ) extends Defn with Member.Type
--   @ast class EnumCase(
      forall {m}. String -> Type m -> Element m
def String
"Defn.EnumCase" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: Data.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       ctor: Ctor.Primary,
          String
"ctor"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ctor.Primary",
--       inits: List[Init]
          String
"inits"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Init"],
--   ) extends Defn with Member.Data { @
--     checkParent(ParentChecks.EnumCase)
--   }
--   @ast class RepeatedEnumCase(
      forall {m}. String -> Type m -> Element m
def String
"Defn.RepeatedEnumCase" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       cases: List[Data.Name]
          String
"cases"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Name"],
--   ) extends Defn {
--     checkParent(ParentChecks.EnumCase)
--   }
--   @ast class GivenAlias(
      forall {m}. String -> Type m -> Element m
def String
"Defn.GivenAlias" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: scala.meta.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       sparams: List[List[Data.Param]],
          String
"sparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
--       decltpe: scala.meta.Type,
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
--       body: Data
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   ) extends Defn
--   @ast class ExtensionGroup(
      forall {m}. String -> Type m -> Element m
def String
"Defn.ExtensionGroup" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       paramss: List[List[Data.Param]],
          String
"parmss"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
--       body: Stat
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Stat"],
--   ) extends Defn
--   @ast class Def(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Def" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: Data.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       paramss: List[List[Data.Param]],
          String
"paramss"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
--       decltpe: Option[scala.meta.Type],
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
--       body: Data
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   ) extends Defn with Member.Data { @
--     checkFields(paramss.forall(onlyLastParamCanBeRepeated))
--   }
--   @ast class Macro(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Macro" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: Data.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       paramss: List[List[Data.Param]],
          String
"paramss"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
--       decltpe: Option[scala.meta.Type],
          String
"decltpe"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type",
--       body: Data
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   ) extends Defn with Member.Data @
--   @ast class Type(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Type" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: scala.meta.Type.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       body: scala.meta.Type
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   ) extends Defn with Member.Type {
--     @binaryCompatField("4.4.0")
--     private var _bounds: scala.meta.Type.Bounds = scala.meta.Type.Bounds(None, None)
--   }
--   @ast class Class(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Class" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: scala.meta.Type.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       ctor: Ctor.Primary,
          String
"ctor"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ctor.Primary",
--       templ: Template
          String
"template"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Template"],
--   ) extends Defn with Member.Type
--   @ast class Trait(
      forall {m}. String -> Type m -> Element m
def String
"Defn.Trait" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: scala.meta.Type.Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type.Name",
--       tparams: List[scala.meta.Type.Param],
          String
"tparams"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Type.Param",
--       ctor: Ctor.Primary,
          String
"ctor"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ctor.Primary",
--       templ: Template
          String
"template"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Template"],
--   ) extends Defn with Member.Type {
--     checkFields(templ.is[Template.Quasi] || templ.stats.forall(!_.is[Ctor]))
--   }
--   @ast class Object(mods: List[Mod], name: Data.Name, templ: Template)
      forall {m}. String -> Type m -> Element m
def String
"Defn.Object" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name"], --  from Member.Data
--       extends Defn with Member.Data { @
--     checkFields(templ.is[Template.Quasi] || templ.stats.forall(!_.is[Ctor]))
--   }
-- }
--
-- @ast class Pkg(ref: Data.Ref, stats: List[Stat]) extends Member.Data with Stat { @
      forall {m}. String -> Type m -> Element m
def String
"Pkg" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name", --  from Member.Data
          String
"ref"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Ref",
          String
"stats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Stat"],
--   checkFields(ref.isQualId)
--   def name: Data.Name = ref match {
--     case name: Data.Name => name
--     case Data.Select(_, name: Data.Name) => name
--   }
-- }
-- object Pkg {
--   @ast class Object(mods: List[Mod], name: Data.Name, templ: Template)
--       extends Member.Data with Stat { @
      forall {m}. String -> Type m -> Element m
def String
"Pkg.Object" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Name",
          String
"template"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Template"],
--     checkFields(templ.is[Template.Quasi] || templ.stats.forall(!_.is[Ctor]))
--   }
-- }
--
-- // NOTE: The names of Ctor.Primary and Ctor.Secondary here is always Name.Anonymous.
-- // While seemingly useless, this name is crucial to one of the key principles behind the semantic API:
-- // "every definition and every reference should carry a name".
-- @branch trait Ctor extends Tree with Member
      forall {m}. String -> Type m -> Element m
def String
"Ctor" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ctor.Primary",
          String
"secondary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ctor.Secondary"],
-- object Ctor {
--   @ast class Primary(mods: List[Mod], name: Name, paramss: List[List[Data.Param]]) extends Ctor
      forall {m}. String -> Type m -> Element m
def String
"Ctor.Primary" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
          String
"paramss"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param"],
--   @ast class Secondary(
      forall {m}. String -> Type m -> Element m
def String
"Ctor.Secondary" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--       mods: List[Mod],
          String
"mods"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Mod",
--       name: Name,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
--       paramss: List[List[Data.Param]] @nonEmpty,
          String
"paramss"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data.Param",
--       init: Init,
          String
"init"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Init",
--       stats: List[Stat]
          String
"stats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Stat"],
--   ) extends Ctor with Stat {
--     checkFields(stats.forall(_.isBlockStat))
--   }
-- }
--
-- // NOTE: The name here is always Name.Anonymous.
-- // See comments to Ctor.Primary and Ctor.Secondary for justification.
-- @ast class Init(tpe: Type, name: Name, argss: List[List[Data]]) extends Ref {
      forall {m}. String -> Type m -> Element m
def String
"Init" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
          String
"argss"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data"],
--   checkFields(tpe.isConstructable)
--   checkParent(ParentChecks.Init)
-- }
--
-- @ast class Self(name: Name, decltpe: Option[Type]) extends Member
      forall {m}. String -> Type m -> Element m
def String
"Self"
        forall m. Type m
unit,
--
-- @ast class Template(
      forall {m}. String -> Type m -> Element m
def String
"Template" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
--     early: List[Stat],
          String
"early"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Stat",
--     inits: List[Init],
          String
"inits"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Init",
--     self: Self,
          String
"self"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Self",
--     stats: List[Stat]
          String
"stats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Stat"],
-- ) extends Tree {
--   @binaryCompatField("4.4.0")
--   private var _derives: List[Type] = Nil
--   checkFields(early.forall(_.isEarlyStat && inits.nonEmpty))
--   checkFields(stats.forall(_.isTemplateStat))
-- }
--
-- @branch trait Mod extends Tree
      forall {m}. String -> Type m -> Element m
def String
"Mod" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"annot"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Mod.Annot",
          String
"private"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Mod.Private",
          String
"protected"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Mod.Protected",
          String
"implicit"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"final"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"sealed"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"open"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"super"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"override"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"case"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"abstract"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"covariant"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"contravariant"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"lazy"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"valParam"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"varParam"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"infix"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"inline"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"using"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"opaque"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"transparent"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],
-- object Mod {
--   @ast class Annot(init: Init) extends Mod {
      forall {m}. String -> Type m -> Element m
def String
"Mod.Annot" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"init"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Init"],
--     @deprecated("Use init instead", "1.9.0")
--     def body = init
--   }
--   @ast class Private(within: Ref) extends Mod {
      forall {m}. String -> Type m -> Element m
def String
"Mod.Private" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"within"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ref"],
--     checkFields(within.isWithin)
--   }
--   @ast class Protected(within: Ref) extends Mod {
      forall {m}. String -> Type m -> Element m
def String
"Mod.Protected" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"within"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Ref"],
--     checkFields(within.isWithin)
--   }
--   @ast class Implicit() extends Mod
--   @ast class Final() extends Mod
--   @ast class Sealed() extends Mod
--   @ast class Open() extends Mod
--   @deprecated("Super traits introduced in dotty, but later removed.")
--   @ast class Super() extends Mod
--   @ast class Override() extends Mod
--   @ast class Case() extends Mod
--   @ast class Abstract() extends Mod
--   @ast class Covariant() extends Mod
--   @ast class Contravariant() extends Mod
--   @ast class Lazy() extends Mod
--   @ast class ValParam() extends Mod
--   @ast class VarParam() extends Mod
--   @ast class Infix() extends Mod
--   @ast class Inline() extends Mod
--   @ast class Using() extends Mod
--   @ast class Opaque() extends Mod
--   @ast class Transparent() extends Mod
-- }
--
-- @branch trait Enumerator extends Tree
      forall {m}. String -> Type m -> Element m
def String
"Enumerator" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"generator"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Enumerator.Generator",
          String
"caseGenerator"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Enumerator.CaseGenerator",
          String
"val"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Enumerator.Val",
          String
"guard"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Enumerator.Guard"],
-- object Enumerator {
--   @ast class Generator(pat: Pat, rhs: Data) extends Enumerator
      forall {m}. String -> Type m -> Element m
def String
"Enumerator.Generator" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"pat"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class CaseGenerator(pat: Pat, rhs: Data) extends Enumerator
      forall {m}. String -> Type m -> Element m
def String
"Enumerator.CaseGenerator" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"pat"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class Val(pat: Pat, rhs: Data) extends Enumerator
      forall {m}. String -> Type m -> Element m
def String
"Enumerator.Val" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"pat"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
--   @ast class Guard(cond: Data) extends Enumerator
      forall {m}. String -> Type m -> Element m
def String
"Enumerator.Guard" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
-- }
--
-- @branch trait ImportExportStat extends Stat {
      forall {m}. String -> Type m -> Element m
def String
"ImportExportStat" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"import"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Import",
          String
"export"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Export"],
--   def importers: List[Importer]
-- }
-- @ast class Import(importers: List[Importer] @nonEmpty) extends ImportExportStat
      forall {m}. String -> Type m -> Element m
def String
"Import" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"importers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Importer"],
-- @ast class Export(importers: List[Importer] @nonEmpty) extends ImportExportStat
      forall {m}. String -> Type m -> Element m
def String
"Export" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"importers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Importer"],
--
-- @ast class Importer(ref: Data.Ref, importees: List[Importee] @nonEmpty) extends Tree {
      forall {m}. String -> Type m -> Element m
def String
"Importer" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"ref"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data.Ref",
          String
"importees"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Importee"],
--   checkFields(ref.isStableId)
-- }
--
-- @branch trait Importee extends Tree with Ref
      forall {m}. String -> Type m -> Element m
def String
"Importee" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"wildcard"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"given"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Importee.Given",
          String
"givenAll"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Importee.Name",
          String
"rename"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Importee.Rename",
          String
"unimport"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Importee.Unimport"],
-- object Importee {
--   @ast class Wildcard() extends Importee
--   @ast class Given(tpe: Type) extends Importee
      forall {m}. String -> Type m -> Element m
def String
"Importee.Given" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"tpe"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--   @ast class GivenAll() extends Importee
--   @ast class Name(name: scala.meta.Name) extends Importee {
      forall {m}. String -> Type m -> Element m
def String
"Importee.Name" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name"],
--     checkFields(name.is[scala.meta.Name.Quasi] || name.is[scala.meta.Name.Indeterminate])
--   }
--   @ast class Rename(name: scala.meta.Name, rename: scala.meta.Name) extends Importee {
      forall {m}. String -> Type m -> Element m
def String
"Importee.Rename" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name",
          String
"rename"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name"],
--     checkFields(name.is[scala.meta.Name.Quasi] || name.is[scala.meta.Name.Indeterminate])
--     checkFields(rename.is[scala.meta.Name.Quasi] || rename.is[scala.meta.Name.Indeterminate])
--   }
--   @ast class Unimport(name: scala.meta.Name) extends Importee {
      forall {m}. String -> Type m -> Element m
def String
"Importee.Unimport" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Name"],
--     checkFields(name.is[scala.meta.Name.Quasi] || name.is[scala.meta.Name.Indeterminate])
--   }
-- }
--
-- @branch trait CaseTree extends Tree {
      forall {m}. String -> Type m -> Element m
def String
"CaseTree" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"case"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Case",
          String
"typeCase"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"TypeCase"],
--   def pat: Tree
--   def body: Tree
-- }
-- @ast class Case(pat: Pat, cond: Option[Data], body: Data) extends CaseTree
      forall {m}. String -> Type m -> Element m
def String
"Case" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"pat"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Pat",
          String
"cond"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Data",
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Data"],
-- @ast class TypeCase(pat: Type, body: Type) extends CaseTree
      forall {m}. String -> Type m -> Element m
def String
"TypeCase" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"pat"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type",
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
meta String
"Type"],
--
-- @ast class Source(stats: List[Stat]) extends Tree {
      forall {m}. String -> Type m -> Element m
def String
"Source" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"stats"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
meta String
"Stat"],
--   // NOTE: This validation has been removed to allow dialects with top-level terms.
--   // Ideally, we should push the validation into a dialect-specific prettyprinter when -- 220 is fixed.
--   // checkFields(stats.forall(_.isTopLevelStat))
-- }
--
-- package internal.trees {
--   // NOTE: Quasi is a base trait for a whole bunch of classes.
--   // Every root, branch and ast trait/class among scala.meta trees (except for quasis themselves)
--   // has a corresponding quasi, e.g. Data.Quasi or Type.Quasi.
--   //
--   // Here's how quasis represent unquotes
--   // (XXX below depends on the position where the unquote occurs, e.g. q"$x" will result in Data.Quasi):
--   //   * $x => XXX.Quasi(0, XXX.Name("x"))
--   //   * ..$xs => XXX.Quasi(1, XXX.Quasi(0, XXX.Name("xs"))
--   //   * ...$xss => XXX.Quasi(2, XXX.Quasi(0, XXX.Name("xss"))
--   //   * ..{$fs($args)} => Complex ellipses aren't supported yet
--   @branch trait Quasi extends Tree {
      forall {m}. String -> Type m -> Element m
def String
"Quasi" --  TODO
        forall m. Type m
unit]
--     def rank: Int
--     def tree: Tree
--     def pt: Class[_]
--     def become[T <: Quasi: AstInfo]: T
--   }
--
--   @registry object All
-- }