// -*- javascript -*-
// Syntactic extensions to ES5 for Syndicate/js. See compiler.js for
// the rest of the translator.

Syndicate <: ES5 {
  //---------------------------------------------------------------------------
  // Extensions to expressions.

  Statement
    += ActorStatement
    | DataspaceStatement
    | ActorFacetStatement
    | AssertionTypeDeclarationStatement
    | FieldDeclarationStatement
    | SendMessageStatement

  FunctionBodyBlock = "{" FunctionBody "}"   // odd that this isn't in es5.ohm somewhere

  ActorStatement
    = actor (named Expression<withIn>)? FunctionBodyBlock

  DataspaceStatement
    = ground dataspace identifier? FunctionBodyBlock -- ground
    | dataspace FunctionBodyBlock                    -- normal

  ActorFacetStatement
    = react FacetBlock until FacetStateTransitionBlock   -- state
    | react until FacetStateTransitionBlock              -- until
    | react FacetBlock                                   -- forever

  AssertionTypeDeclarationStatement
    = (assertion | message) type identifier "(" FormalParameterList ")" ("=" stringLiteral)? #(sc)

  FieldDeclarationStatement = field MemberExpression "=" AssignmentExpression<withIn> #(sc)
  MemberExpression += field MemberExpression -- fieldRefExp
  UnaryExpression += delete field MemberExpression -- fieldDelExp

  SendMessageStatement = "::" Expression<withIn> #(sc)

  //---------------------------------------------------------------------------
  // Ongoing event handlers.

  FacetBlock = "{"
    (VariableStatement | FieldDeclarationStatement | FunctionDeclaration)*
    FacetInitBlock?
    FacetSituation*
    FacetDoneBlock?
    "}"
  FacetStateTransitionBlock = "{" FacetStateTransition* "}"

  FacetInitBlock = do FunctionBodyBlock
  FacetDoneBlock = finally FunctionBodyBlock

  FacetSituation
    = assert FacetPattern AssertWhenClause? #(sc)                      -- assert
    | on FacetEventPattern FunctionBodyBlock                           -- event
    | on event identifier FunctionBodyBlock                            -- onEvent
    | dataflow FunctionBodyBlock                                       -- dataflow
    | during FacetPattern FacetBlock                                   -- during
    | during FacetPattern actor (named Expression<withIn>)? FacetBlock -- duringActor

  AssertWhenClause = when "(" Expression<withIn> ")"

  FacetEventPattern
    = message FacetPattern   -- messageEvent
    | asserted FacetPattern  -- assertedEvent
    | retracted FacetPattern -- retractedEvent

  FacetTransitionEventPattern
    = FacetEventPattern          -- facetEvent
    | "(" Expression<withIn> ")" -- risingEdge

  FacetStateTransition
    = case FacetTransitionEventPattern FunctionBodyBlock -- withContinuation
    | case FacetTransitionEventPattern #(sc)             -- noContinuation

  FacetPattern
    = LeftHandSideExpression metalevel decimalIntegerLiteral -- withMetalevel
    | LeftHandSideExpression                                 -- noMetalevel

  //---------------------------------------------------------------------------
  // Keywords. We don't add them to the "keyword" production because
  // we don't want to make them unavailable to programs as
  // identifiers.

  actor = "actor" ~identifierPart
  assert = "assert" ~identifierPart
  asserted = "asserted" ~identifierPart
  assertion = "assertion" ~identifierPart
  dataflow = "dataflow" ~identifierPart
  dataspace = "dataspace" ~identifierPart
  during = "during" ~identifierPart
  event = "event" ~identifierPart
  field = "field" ~identifierPart
  ground = "ground" ~identifierPart
  message = "message" ~identifierPart
  metalevel = "metalevel" ~identifierPart
  named = "named" ~identifierPart
  on = "on" ~identifierPart
  react = "react" ~identifierPart
  retracted = "retracted" ~identifierPart
  type = "type" ~identifierPart
  until = "until" ~identifierPart
  when = "when" ~identifierPart
}