path: root/scalaParser/src/main/scala/scalaParser/ScalaSyntax.scala

package scalaParser
import acyclic.file
import language.implicitConversions
import syntax._
import org.parboiled2._

/**
 * Parser for Scala syntax.
 */
class ScalaSyntax(val input: ParserInput) extends Parser with Basic with Identifiers with Literals {
  // Aliases for common things. These things are used in almost every parser
  // in the file, so it makes sense to keep them short.
  type R0 = Rule0
  /**
   * Parses all whitespace, excluding newlines. This is only
   * really useful in e.g. {} blocks, where we want to avoid
   * capturing newlines so semicolon-inference would work
   */
  def WS = rule { zeroOrMore(Basic.WhitespaceChar | Literals.Comment) }

  /**
   * Parses whitespace, including newlines.
   * This is the default for most things
   */
  def WL = rule{ zeroOrMore(Basic.WhitespaceChar | Literals.Comment | Basic.Newline) }


  /**
   * By default, all strings and characters greedily
   * capture all whitespace immediately before the token.
   */
  implicit private[this] def wspStr(s: String): R0 = rule { WL ~ str(s)  }
  implicit private[this] def wspChar(s: Char): R0 = rule { WL ~ ch(s) }

  /**
   * Most keywords don't just require the correct characters to match,
   * they have to ensure that subsequent characters *don't* match in
   * order for it to be a keyword. This enforces that rule for key-words
   * (W) and key-operators (O) which have different non-match criteria.
   */
  object K {
    def W(s: String) = rule{ WL ~ Key.W(s) }
    def O(s: String) = rule{ WL ~ Key.O(s) }
  }

  def `=>` = rule{ K.O("=>") | K.O("⇒") }
  def `:` = rule{ K.O(":") }
  def `=` = rule{ K.O("=") }

  def `_` = rule{ K.W("_") }
  def `this` = rule{ K.W("this") }
  def `type` = rule{ K.W("type") }
  def `val` = rule{ K.W("val") }
  def `var` = rule{ K.W("var") }
  def `def` = rule{ K.W("def") }
  def `with` = rule{ K.W("with") }
  def `package` = rule{ K.W("package") }
  def `object` = rule{ K.W("object") }
  def `class` = rule{ K.W("class") }
  def `case` = rule{ K.W("case") }
  def `trait` = rule{ K.W("trait") }
  def `extends` = rule{ K.W("extends") }
  def `implicit` = rule{ K.W("implicit") }

  /**
   * helper printing function
   */
  def pr(s: String) = rule { run(println(s"LOGGING $cursor: $s")) }

  def Id = rule { WL ~ Identifiers.Id }
  def VarId = rule { WL ~ Identifiers.VarId }
  def Literal = rule { WL ~ Literals.Literal }
  def Semi = rule { WS ~ Basic.Semi }
  def Semis = rule { oneOrMore(Semi) }
  def Newline = rule { WL ~ Basic.Newline }

  def QualId = rule { WL ~ oneOrMore(Id).separatedBy('.') }
  def Ids = rule { oneOrMore(Id) separatedBy ',' }

  def NotNewline: R0 = rule{ &( WS ~ noneOf("\n") )}
  def OneNewlineMax: R0 = rule{
    WS ~
    optional(Basic.Newline) ~
    zeroOrMore(
      zeroOrMore(Basic.WhitespaceChar) ~
      Literals.Comment ~
      zeroOrMore(Basic.WhitespaceChar) ~
      Basic.Newline
    ) ~
    NotNewline
  }
  def StableId: R0 = {
    def ClassQualifier = rule { '[' ~ Id ~ ']' }
    rule {
      zeroOrMore(Id ~ '.') ~ (`this` | K.W("super") ~ optional(ClassQualifier)) ~ zeroOrMore('.' ~ Id) |
      Id ~ zeroOrMore('.' ~ Id)
    }
  }
  def ExistentialDcl = rule { `type` ~ TypeDcl | `val` ~ ValDcl }
  def ExistentialClause = rule {
    "forSome" ~ '{' ~ oneOrMore(ExistentialDcl).separatedBy(Semi) ~ '}'
  }
  def Type: R0 = {
    def WildcardType: R0 = rule{ `_` }

    def FunctionArgTypes = rule {
      InfixType | '(' ~ optional(oneOrMore(ParamType) separatedBy ',') ~ ')'
    }
    rule {
      (WildcardType |
      FunctionArgTypes ~ `=>` ~ Type |
      InfixType ~ optional(ExistentialClause)) ~ TypeBounds
    }
  }

  def InfixType = rule {
    CompoundType ~ zeroOrMore(Id ~ OneNewlineMax ~ CompoundType)
  }
  def CompoundType = {
    def RefineStat = rule { `type` ~ TypeDef | Dcl | MATCH }
    def Refinement = rule {
      OneNewlineMax ~ '{' ~ oneOrMore(RefineStat).separatedBy(Semi) ~ "}"
    }
    rule {
      oneOrMore(AnnotType).separatedBy(`with`) ~ optional(Refinement) |
      Refinement
    }
  }
  def AnnotType = rule {
    SimpleType ~ optional(NotNewline ~ oneOrMore(NotNewline ~ Annotation))
  }
  def SimpleType: R0 = {
    def BasicType: R0 = rule {
      '(' ~ Types ~ ')'  | StableId ~ '.' ~ `type` | StableId
    }
    rule{ BasicType ~ zeroOrMore(TypeArgs | '#' ~ Id) }
  }

  def TypeArgs = rule { '[' ~ Types ~ "]" }
  def Types = rule { oneOrMore(Type).separatedBy(',') }


  def TypePat = rule { CompoundType }
  def FunctionArgTypes = rule {
    InfixType | '(' ~ optional(oneOrMore(ParamType) separatedBy ',') ~ ')'
  }
  def Ascription = rule {
     ":" ~ ("_" ~ "*" |  InfixType | oneOrMore(Annotation))
  }

  def ParamType = rule { `=>` ~ Type | Type ~ "*" | Type }

  def LambdaHead: R0 = {
    def Bindings: R0 = {
      def Binding: R0 = rule { (Id | `_`) ~ optional(`:` ~ Type) }
      rule { '(' ~ zeroOrMore(Binding).separatedBy(',') ~ ')' }
    }
    rule{
      (
        Bindings |
        optional(`implicit`) ~ Id ~ optional(Ascription) |
        `_` ~ optional(Ascription)
      ) ~
      `=>`
    }
  }
  def Enumerators(G: Boolean = false): R0 = {
    def Generator: R0 = rule {
      Pattern1 ~ (K.O("<-") | K.O("←"))~ Expr0(G) ~ optional(Guard(G))
    }
    def Enumerator: R0 = rule { Generator | Guard(G) | Pattern1 ~ `=` ~ Expr0(G) }
    rule { Generator ~ zeroOrMore(Semis ~ Enumerator) ~ WL }
  }
  def Expr = Expr0()
  def ExprSensitive = Expr0(true)
  def Expr0(G: Boolean = false): R0 = {
    def IfCFlow = rule {
      "if" ~ '(' ~ Expr ~ ')' ~ Expr0(G) ~ optional(optional(Semi) ~ K.W("else") ~ Expr0(G))
    }
    def WhileCFlow = rule { "while" ~ '(' ~ Expr ~ ')' ~ Expr0(G) }
    def TryCFlow = rule {
      K.W("try") ~ Expr0(G) ~
      optional(K.W("catch") ~ Expr0(G)) ~
      optional(K.W("finally") ~ Expr0(G))
    }

    def DoWhileCFlow = rule {
      K.W("do") ~ Expr0(G) ~ optional(Semi) ~ "while" ~ '(' ~ Expr ~ ")"
    }
    def ForCFlow = {

      rule {
        "for" ~
        ('(' ~ Enumerators() ~ ')' | '{' ~ Enumerators(G = true) ~ '}') ~
        optional(K.W("yield")) ~
        Expr0(G)
      }
    }
    rule {
      zeroOrMore(LambdaHead) ~ (
        IfCFlow |
        WhileCFlow |
        TryCFlow |
        DoWhileCFlow |
        ForCFlow |
        K.W("throw") ~ Expr0(G) |
        K.W("return") ~ optional(Expr0(G)) |
        SimpleExpr ~ `=` ~ Expr0(G) |
        PostfixExpr(G) ~ optional("match" ~ '{' ~ CaseClauses ~ "}" | Ascription)
      )
    }
  }

  def PostfixExpr(G: Boolean = false): R0 = {
    def PrefixExpr = rule {
      optional(WL ~ anyOf("-+~!") ~ WS ~ !(Basic.OperatorChar)) ~  SimpleExpr
    }
    def Check = if (G) OneNewlineMax else MATCH
    def Check0 = if (G) NotNewline else MATCH
    def InfixExpr: R0 = rule {
      PrefixExpr ~
      zeroOrMore(
        Check0 ~
        Id ~
        optional(TypeArgs) ~
        Check ~
        PrefixExpr
      )
    }
    rule { InfixExpr ~ optional(NotNewline ~ Id ~ optional(Newline)) }
  }

  def SimpleExpr: R0 = {
    def Path: R0 = rule {
      zeroOrMore(Id ~ '.') ~ `this` ~ zeroOrMore('.' ~ Id) |
      StableId
    }
    def SimpleExpr1 = rule{
      K.W("new") ~ (ClassTemplate | TemplateBody) |
      BlockExpr |
      Literal |
      Path |
      `_` |
      '(' ~ optional(Exprs) ~ ")"
    }
    rule {
      SimpleExpr1 ~
      zeroOrMore('.' ~ Id | TypeArgs | NotNewline ~ ArgumentExprs) ~
      optional(`_`)
    }
  }

  def Exprs: R0 = rule { oneOrMore(Expr).separatedBy(',') }
  def ArgumentExprs: R0 = rule {
    '(' ~ optional(Exprs ~ optional(`:` ~ `_` ~ '*')) ~ ")" |
      OneNewlineMax ~ BlockExpr
  }

  def BlockExpr: R0 = rule { '{' ~ (CaseClauses | Block) ~ optional(Semis) ~  "}" }

  def BlockStats: R0 = {
    def Template: R0 = rule{
      zeroOrMore(Annotation) ~
      (optional(`implicit`) ~ optional(K.W("lazy")) ~ Def | zeroOrMore(LocalModifier) ~ TmplDef)
    }
    def BlockStat: R0 = rule {
      Import |
      Template |
      Expr0(true)
    }
    rule{ oneOrMore(BlockStat).separatedBy(Semis) }
  }

  def Block: R0 = {
    def BlockEnd: R0 = rule{ optional(Semis) ~ &("}" | `case`) }
    def ResultExpr: R0 = Expr0(true)
    rule {
      zeroOrMore(LambdaHead) ~
      optional(Semis) ~
      (
        ResultExpr ~ BlockEnd |
        BlockStats ~ optional(Semis ~ ResultExpr) ~ BlockEnd |
        MATCH ~ BlockEnd
      )
    }
  }

  def CaseClauses: R0 = {
    def CaseClause: R0 = rule { `case` ~ Pattern ~ optional(Guard()) ~ `=>` ~ Block }
    rule { oneOrMore(CaseClause) }
  }

  def Guard(G: Boolean = false): R0 = rule { K.W("if") ~ PostfixExpr(G) }
  def Pattern: R0 = rule {
    oneOrMore(Pattern1).separatedBy('|')
  }
  def Pattern1: R0 = rule { `_` ~ `:` ~ TypePat | VarId ~ `:` ~ TypePat | Pattern2 }
  def Pattern2: R0 = {
    def Pattern3: R0 = rule {
      `_` ~ '*' | SimplePattern ~ zeroOrMore(Id ~ SimplePattern)
    }
    rule{ VarId ~ "@" ~ Pattern3 | Pattern3 | VarId }
  }

  def SimplePattern: R0 = {

    def ExtractorArgs = rule{ zeroOrMore(Pattern).separatedBy(',') }
    def Extractor: R0 = rule{ StableId ~ optional('(' ~ ExtractorArgs ~ ')') }
    rule {
      `_` ~ optional(`:` ~ TypePat) ~ !("*") |
      Literal |
      '(' ~ optional(ExtractorArgs) ~ ')' |
      Extractor |
      VarId
    }
  }


  def TypeParamClause: R0 = {
    def VariantTypeParam: R0 = rule { zeroOrMore(Annotation) ~ optional(WL ~ anyOf("+-")) ~ TypeParam }
    rule { '[' ~ oneOrMore(VariantTypeParam).separatedBy(',') ~ ']' }
  }
  def FunTypeParamClause: R0 = rule {
    '[' ~ oneOrMore(zeroOrMore(Annotation) ~ TypeParam).separatedBy(',') ~ ']'
  }
  def TypeBounds: R0 = rule{ optional(K.O(">:") ~ Type) ~ optional(K.O("<:") ~ Type) }
  def TypeParam: R0 = rule {
    (Id | `_`) ~
    optional(TypeParamClause) ~
    TypeBounds ~
    zeroOrMore(K.O("<%") ~ Type) ~
    zeroOrMore(`:` ~ Type)
  }
  def ParamClauses: R0 = rule {
    zeroOrMore(ParamClause) ~ optional(OneNewlineMax ~ '(' ~ `implicit` ~ Params ~ ')')
  }
  def ParamClause: R0 = rule { OneNewlineMax ~ '(' ~ optional(Params) ~ ')' }
  def Params: R0 = {
    def Param: R0 = rule {
      zeroOrMore(Annotation) ~ Id ~ optional(`:` ~ ParamType) ~ optional(`=` ~ Expr)
    }
    rule { zeroOrMore(Param).separatedBy(',') }
  }

  def ClassParam: R0 = rule {
    zeroOrMore(Annotation) ~
    optional(zeroOrMore(Modifier) ~ (`val` | `var`)) ~
    Id ~
    `:` ~
    ParamType ~
    optional(`=` ~ Expr)
  }

  def Modifier: R0 = rule { LocalModifier | AccessModifier | K.W("override") }
  def LocalModifier: R0 = rule { K.W("abstract") | K.W("final") | K.W("sealed") | `implicit` | K.W("lazy") }
  def AccessModifier: R0 = {
    def AccessQualifier: R0 = rule { '[' ~ (`this` | Id) ~ ']' }
    rule { (K.W("private") | K.W("protected")) ~ optional(AccessQualifier) }
  }

  def Annotation: R0 = rule {  '@' ~  SimpleType ~  zeroOrMore(ArgumentExprs)  }

  def TemplateBody: R0 = rule {
    '{' ~
    optional(SelfType) ~
    zeroOrMore(TemplateStat).separatedBy(Semis) ~
    optional(Semis) ~
    '}'
  }
  def TemplateStat: R0 = rule {
    Import |
    zeroOrMore(Annotation ~ OneNewlineMax) ~ zeroOrMore(Modifier) ~ (Def | Dcl) |
    Expr0(true)
  }

  def SelfType: R0 = rule {
    `this` ~ `:` ~ InfixType ~ `=>` | (Id | `_`) ~ optional(`:` ~ InfixType) ~ `=>`
  }

  def Import: R0 = {
    def ImportExpr: R0 = rule {
      StableId ~ optional('.' ~ (`_` | ImportSelectors))
    }
    def ImportSelectors: R0 = rule {
      '{' ~ zeroOrMore(ImportSelector ~ ',') ~ (ImportSelector | `_`) ~ "}"
    }
    def ImportSelector: R0 = rule { Id ~ optional(`=>` ~ (Id | `_`)) }
    rule { K.W("import") ~ oneOrMore(ImportExpr).separatedBy(',') }
  }

  def Dcl: R0 = {
    def VarDcl: R0 = rule { Ids ~ `:` ~ Type }
    def FunDcl: R0 = rule { FunSig ~ optional(`:` ~ Type) }
    rule{ `val` ~ ValDcl | `var` ~ VarDcl | `def` ~ FunDcl | `type` ~ TypeDcl }
  }
  def FunSig: R0 = rule { Id ~ optional(FunTypeParamClause) ~ ParamClauses }
  def ValDcl: R0 = rule { Ids ~ `:` ~ Type }
  def TypeDcl: R0 = rule { Id ~ optional(TypeParamClause) ~ TypeBounds }

  def PatVarDef: R0 = {
    def PatDef: R0 = rule { oneOrMore(Pattern2).separatedBy(',') ~ optional(`:` ~ Type) ~ `=` ~ Expr0(true) }
    def VarDef: R0 = rule { Ids ~ `:` ~ Type ~ `=` ~ `_` | PatDef }
    rule { `val` ~ PatDef | `var` ~ VarDef }
  }
  def Def: R0 = {
    def ConstrExpr: R0 = rule { ConstrBlock | SelfInvocation }
    def FunDef: R0 = rule {
      `this` ~ ParamClause ~ ParamClauses ~ (`=` ~ ConstrExpr | OneNewlineMax ~ ConstrBlock) |
      FunSig ~ optional(`:` ~ Type) ~ (
        `=` ~ optional(K.W("macro")) ~ Expr0(true) |
        OneNewlineMax ~ '{' ~ Block ~ "}"
      )
    }
    rule { `def` ~ FunDef | `type` ~ TypeDef | PatVarDef | TmplDef }
  }

  def TypeDef: R0 = rule { Id ~ optional(TypeParamClause) ~ `=` ~ Type }

  def TmplDef: R0 = {
    def TraitTemplate: R0 = {
      def TraitParents: R0 = rule { AnnotType ~ zeroOrMore(`with` ~ AnnotType) }
      rule{ optional(EarlyDefs) ~ TraitParents ~ optional(TemplateBody) }
    }
    def ClassParamClauses: R0 = {
      def Implicit: R0 = rule{
        OneNewlineMax ~
        '(' ~
        `implicit` ~
        oneOrMore(ClassParam).separatedBy(",") ~
        ")"
      }

      def ClassParamClause: R0 = {
        def ClassParams: R0 = rule { oneOrMore(ClassParam).separatedBy(',') }
        rule { OneNewlineMax ~'(' ~ optional(ClassParams) ~ ")" }
      }
      rule {
        oneOrMore(ClassParamClause) ~ optional(Implicit) | Implicit
      }
    }
    def ConstrPrelude: R0 = {
      def Annot: R0 = rule { '@' ~ SimpleType ~ ArgumentExprs }
      rule{
        NotNewline ~ (
          oneOrMore(Annot) ~ optional(AccessModifier) |
          zeroOrMore(Annot) ~ AccessModifier
        )
      }
    }
    def ClassDef: R0 = rule {
      Id ~
      optional(TypeParamClause) ~
      optional(ConstrPrelude) ~
      optional(ClassParamClauses) ~
      ClassTemplateOpt
    }
    def TraitTemplateOpt: R0 = rule {
      `extends` ~ TraitTemplate | optional(optional(`extends`) ~ TemplateBody)
    }
    def TraitDef: R0 = rule { Id ~ optional(TypeParamClause) ~ TraitTemplateOpt }
    rule {
      `trait` ~ TraitDef |
      optional(`case`) ~ (`class` ~ ClassDef | `object` ~ ObjectDef)
    }
  }


  def ObjectDef: R0 = rule { Id ~ ClassTemplateOpt }
  def ClassTemplateOpt: R0 = rule {
    `extends` ~ ClassTemplate | optional(optional(`extends`) ~ TemplateBody)
  }

  def ClassTemplate: R0 = {
    def ClassParents: R0 = {
      def Constr: R0 = rule{ AnnotType ~ zeroOrMore(NotNewline ~ ArgumentExprs) }
      rule{ Constr ~ zeroOrMore(`with` ~ AnnotType) }
    }
    rule{ optional(EarlyDefs) ~ ClassParents ~ optional(TemplateBody) }
  }

  def EarlyDefs: R0 = {
    def EarlyDef: R0 = rule {
      zeroOrMore(Annotation ~ OneNewlineMax) ~ zeroOrMore(Modifier) ~ PatVarDef
    }
    rule{ '{' ~ optional(oneOrMore(EarlyDef).separatedBy(Semis)) ~ '}' ~ `with` }
  }

  def ConstrBlock: R0 = rule { '{' ~ SelfInvocation ~ optional(Semis ~ BlockStats) ~ optional(Semis) ~ '}' }
  def SelfInvocation: R0 = rule { `this` ~ oneOrMore(ArgumentExprs) }

  def TopStatSeq: R0 = {
    def PackageObject: R0 = rule { `package` ~ `object` ~ ObjectDef }
    def Packaging: R0 = rule {
      `package` ~ QualId ~ '{' ~ optional(TopStatSeq) ~ WL ~ '}'
    }
    def TopStat: R0 = rule {
      Packaging |
      PackageObject |
      Import |
      zeroOrMore(Annotation ~ OneNewlineMax) ~ zeroOrMore(Modifier) ~ TmplDef
    }
    rule { oneOrMore(TopStat).separatedBy(Semis) }
  }

  def CompilationUnit: Rule1[String] = {
    def TopPackageSeq: R0 = rule{
      oneOrMore(`package` ~ QualId ~ !(WS ~ "{")).separatedBy(Semis)
    }
    rule {
      capture(
        optional(Semis) ~
        (TopPackageSeq ~ optional(Semis ~ TopStatSeq) | TopStatSeq | MATCH) ~
        optional(Semis) ~
        WL
      )
    }
  }
}