typescript.grammar

extends "./javascript.grammar"

skip whitespace {
  context Statement {
    type typeDeclName TypeParams? op("=") Type semi |
    namespace (~(identifier ".") variable ".")* declName Block |
    interface typeDeclName TypeParams? (extends CommaSep(Type))? ObjType |
    (~(kw("const") enum) kw("const") enum | enum) typeDeclName EnumBody |
    (declare | kw("abstract")) Statement |
    super
  }

  context TypeParams { "<" CommaSep(typeDeclName (extends Type)? (op("=") Type)?) ">" }

  context TypeArgs { "<" CommaSep(Type) ">" }

  Type { TypeAtom TypeSuffix* }

  TypeAtom {
    kw("this") |
    atom |
    kw("typeof") variable ("." propName | "[" Expression "]")* |
    kw("keyof" | "readonly" | "unique") Type |
    ~("(" !(")" | "..." | identifier ("?" | ":"))) "(" Type ")" |
    new? TypeParams? ParamListSpec op("=>") RetType |
    (~(identifier ".") variable ".")* typeName TypeArgs? |
    TupleType |
    ObjType |
    string |
    number
  }

  TypeSuffix {
    (op("&" | "|") | kw("extends")) Type |
    "[" Type? "]" |
    op("?") Type op(":") Type
  }

  TypeAnn {
    ":" Type
  }

  RetType {
    (~(identifier kw("is")) variable kw("is"))? Type
  }

  context ParamListSpec { ParamList }

  context ParamList { // FIXME typing comes before default values
    "(" CommaSep(Decorator* modifier* "..."? Pattern "?"? TypeAnn? (op("=") ExpressionNoComma)?) ")"
  }

  context ObjType { "{" ObjTypeField? (("," | ";") ObjTypeField?)* "}" }

  context TupleType { "[" CommaSep((labelName ":")? Type) "]" }

  ObjTypeField {
    new? TypeParams? ParamList (":" RetType)? |
    modifier* ("[" (~(identifier (":" | "in")) identifier (":" | kw("in")) Type | Expression) "]" TypeAnn |
               (propDeclName | string | number) "?"? (TypeParams? ParamList)? (":" RetType)?)
  }

  Callee { calleeName TypeArgs? }

  NewExpression { new ("." kw("target") | calleeName TypeArgs? | BaseExpression) }

  context ArrowRest { op("=>") TypeParams? (Block | ExpressionNoComma) }

  ExpressionSuffix(ContExpression) {
    kw("as") Type |
    op("!") |
    suffixOp |
    (binOp | kwBinOp) ContExpression |
    ArgList |
    template |
    ("." | "?.") (calleeProp TypeArgs? | propName) |
    "[" Expression "]" |
    op("?") Expression op(":") ContExpression
  }

  BaseExpression {
    "<" Type ">" BaseExpression |
    super
  }

  context FunctionDef {
    TypeParams? ParamList (":" RetType)? (Block | semi)
  }

  ClassDef {
    TypeParams? (extends Type)? (kw("implements") CommaSep(Type))? ClassBody
  }

  context ClassBody {
    "{" ((modifier | override)* ClassItem | Decorator)* "}"
  }

  context ClassItem {
    propModifier?
    (propDeclName | "[" Expression "]" | number | string)
    (asyncStar? FunctionDef | ("!" | "?")? TypeAnn? (op("=") Expression)? semi)
  }

  VariableDeclarator { Pattern op("!")? TypeAnn? (op("=") ExpressionNoComma)? }

  context EnumBody { "{" CommaSep(propDeclName (op("=") ExpressionNoComma)?) "}" }

  ParamsAndArrow { ~(ParamList (":" RetType)? "=>") ParamList (":" RetType)? }
}

modifier { kw("public" | "private" | "protected" | "readonly" | "abstract" | "static") }
enum { kw("enum") }

propModifier { kw("get" | "set" | "async") !(" "* ("," | "}" | ":" | "(" | "<")) }

typeDeclName="def type" { identifier }
typeName="type" { identifier }

calleeName="variable callee" { identifier ~("<" !" " | " "* (typeArgStructure " "*)? "(") }
calleeProp="property callee" { identifier ~(" "* (typeArgStructure " "*)? "(") }

typeArgStructure { "<" (typeArgStructure | "=>" | !">" _)* ">" }

declNameAndArrow { declName ~(whitespace (":" whitespace Type whitespace)? "=>") }

type { kw("type") ~(spaceChar* identifierStart) }
namespace { kw("namespace") ~(spaceChar* identifierStart) }
interface { kw("interface") ~(spaceChar* identifierStart) }
declare { kw("declare") ~(spaceChar* identifierStart) }
override { kw("override") ~(spaceChar* identifierStart) }