webdsl-ui.stx

pdmosses/webdsl-statix/webdslstatix/trans/static-semantics/webdsl-ui.stx

module static-semantics/webdsl-ui

imports
  static-semantics/actions/functions

  static-semantics/entities/annotations

  static-semantics/types/built-ins

  static-semantics/ui/actions
  static-semantics/ui/ajax
  static-semantics/ui/attributes
  static-semantics/ui/built-ins
  static-semantics/ui/template-calls

  static-semantics/webdsl-actions
  static-semantics/webdsl-types
  static-semantics/webdsl

rules // unimplemented definitions

  defOk(_, TemplateDefinition(Define(_, t, _, _, _))) :- false | error $[Could not desugar define to an email, template or page definition] @t.
  defOk(_, TemplateDefinition(LocalRedefine(_, t, _, _, _))) :- try { false } | warning $[This definition is not yet implemented] @t.
  defOk(_, TemplateDefinition(DefineEmail(_, e, _, _, _))) :- try { false } | warning $[Email definitions are not yet implemented] @e.

  defOk(_, TemplateDefinition(HTMLWrapper2TemplateDefinition(_))) :- false | error $[Could not desugar to template definitions].
  defOk(_, TemplateDefinition(HTMLWrapperMultiple(_))) :- false | error $[Could not desugar to template definitions].

rules // page definitions

  defOk(s, TemplateDefinition(DefinePage(mods, x, FormalArgs(fargs), TemplateArgs(targs), elements))) :- {fargTypes s_page s_pha s_body}
    pageModsOk(s, mods),
    targs == [] | error $[Template arguments are not allowed on page definitions] @targs,
    new s_page, s_page -F-> s,
    fargTypes == typesOfArgs(s, fargs),
    declareParameters(s_page, zipArgTypes(fargs, fargTypes)),
    new s_pha, s_pha -P-> s_page,
    new s_body, s_body -P-> s_pha,
    optionallyDeclarePage(s, x, fargTypes, notB(isOverrideB(mods))),
    overriddenElementExists(s, Page(), x, FALSE(), isOverrideB(mods)),
    templateElementOrderOk(elements, FALSE(), FALSE()),
    templateElementsOk(s_body, s_pha, elements).

  optionallyDeclarePage : scope * string * list(TYPE) * BOOL
  optionallyDeclarePage(_, _, _, FALSE()).
  optionallyDeclarePage(s, x, fargTypes, TRUE()) :- declarePage(s, x, fargTypes).

  pageModsOk maps pageModOk(*, list(*))
  pageModOk : scope * Modifier
  pageModOk(_, _) :- try { false } | warning $[This modifier is not yet implemented].
  pageModOk(_, AjaxTemplate()) :- false | error $[A page cannot be an ajax template].
  pageModOk(_, WebService()) :- false | error $[To define a webservice, use "webservice myWebservice(...) { ... }"].
  pageModOk(_, TemplateModOverride()).
  pageModOk(_, IgnoreAccessControl()).

rules // template definitions

  defOk(s, TemplateDefinition(td@DefineTemplate(_, _, _, _, _))) :- defineTemplateOk(s, td).

  // last BOOL defines if the template is top-level (TRUE) or nested (FALSE)
  defineTemplateOk : scope * TemplateDefinition
  defineTemplateOk(s, DefineTemplate(mods, t, FormalArgs(fargs), TemplateArgs(targs), elements)) :- {fargTypes targTypes s_template s_pha s_body}
    templateModsOk(s, mods),
    new s_template, s_template -F-> s,
    fargTypes == typesOfArgs(s, fargs),
    targTypes == typesOfTemplateArgs(s, targs),
    declareParameters(s_template, zipArgTypes(fargs, fargTypes)),
    declTArgs(s_template, targTypes),
    new s_pha, s_pha -P-> s_template,
    new s_body, s_body -P-> s_pha,
    optionallyDeclareTemplate(s, t, fargTypes, targTypes, isAjaxTemplate(mods), notB(isOverrideB(mods))),
    overriddenElementExists(s, Template(), t, isAjaxTemplate(mods), isOverrideB(mods)),
    templateElementOrderOk(elements, FALSE(), FALSE()),
    templateElementsOk(s_body, s_pha, elements).

  templateModsOk maps templateModOk(*, list(*))
  templateModOk : scope * Modifier
  templateModOk(_, _) :- try { false } | warning $[This modifier is not yet implemented].
  templateModOk(_, WebService()) :- false | error $[To define a webservice, use "webservice myWebservice(...) { ... }"].
  templateModOk(_, AjaxTemplate()).
  templateModOk(_, TemplateModOverride()).
  templateModOk(_, IgnoreAccessControl()).

  nestedTemplateOk : scope * TemplateDefinition
  nestedTemplateOk(s, DefineTemplate(_, t, FormalArgs(fargs), TemplateArgs(targs), elements)) :- {fargTypes targTypes sigs s_template s_pha s_body}
    new s_template, s_template -P-> s, // use P edge label instead of F to get correct duplicate variable errors and resolve queries correctly
    fargTypes == typesOfArgs(s, fargs),
    targTypes == typesOfTemplateArgs(s, targs),
    declareParameters(s_template, zipArgTypes(fargs, fargTypes)),
    declTArgs(s_template, targTypes),
    sigs == resolveTemplate(s, t),
    matchingSigs(fargTypes, dropPaths(sigs)) == [_] | error $[No template [t] with argument types [fargTypes] exists] @t,
    new s_pha, s_pha -P-> s_template,
    new s_body, s_body -P-> s_pha,
    templateElementOrderOk(elements, FALSE(), FALSE()),
    templateElementsOk(s_body, s_pha, elements).

  isAjaxTemplate : list(Modifier) -> BOOL
  isAjaxTemplate([]) = FALSE().
  isAjaxTemplate([_ | mods]) = isAjaxTemplate(mods).
  isAjaxTemplate([AjaxTemplate() | _]) = TRUE().

  isOverrideB : list(Modifier) -> BOOL
  isOverrideB([]) = FALSE().
  isOverrideB([_ | mods]) = isOverrideB(mods).
  isOverrideB([TemplateModOverride() | _]) = TRUE().

  overriddenElementExists : scope * Modifier * string * BOOL * BOOL
  overriddenElementExists(_, _, _, _, FALSE()).
  overriddenElementExists(s, Page(), p, _, TRUE()) :- resolvePage(s, p) == [(_, (_, _))] | error $[Page [p] does not exist] @p.
  overriddenElementExists(s, Template(), t, FALSE(), TRUE()) :- resolveTemplateNoAjax(s, t) == [(_, (_, _))] | error $[Template [t] does not exist] @t.
  overriddenElementExists(s, Template(), t, TRUE(), TRUE()) :- resolveAjaxTemplate(s, t) == [(_, (_, _))] | error $[Ajax template [t] does not exist] @t.

  optionallyDeclareTemplate : scope * string * list(TYPE) * list((string * list(TYPE))) * BOOL * BOOL
  optionallyDeclareTemplate(_, _, _, _, _, FALSE()).
  optionallyDeclareTemplate(s, t, fargTypes, targTypes, ajax, TRUE()) :- declTemplate(s, t, fargTypes, targTypes, ajax).

  declTemplate : scope * string * list(TYPE) * list((string * list(TYPE))) * BOOL
  declTemplate(s, t, fargTypes, targTypes, ajax) :- {result}
    declareTemplate_internal(s, t, fargTypes, ajax),
    resolveTemplate(s, t) == result,
    amountOfTemplateDeclsWithArgs(result, fargTypes, 0) == 1
      | error $[Multiple page/template definitions with name [t] and argument types [fargTypes]] @t. // correct error message for tests

  declTArgs maps declTArg(*, list(*))
  declTArg : scope * (string * list(TYPE))
  declTArg(s, (t, argTypes)) :-
    declTemplate(s, t, argTypes, [], FALSE()).

  // helper function that results in the amount of template definitions with the given argument types
  amountOfTemplateDeclsWithArgs : list((path *(string * TYPE))) * list(TYPE) * int -> int
  amountOfTemplateDeclsWithArgs([], _, n) = n.
  amountOfTemplateDeclsWithArgs([ (_, (_, TEMPLATE(_, args, _))) | tail], args, n) = amountOfTemplateDeclsWithArgs(tail, args, i) :- i #= n + 1.
  amountOfTemplateDeclsWithArgs([ _ | tail], args, n) = amountOfTemplateDeclsWithArgs(tail, args, n).

rules // template elements

  templateElementOk : scope * scope * scope * TemplateElement // TYPE argument is the return type in a function
  templateElementOk(_, _, _, e) :- try { false } | warning $[This template element is not yet implemented] @e.

  // the second scope (s_pha) is for declaring+resolving of placeholders and actions, which do not have to be declared before use
  templateElementsOk : scope * scope * list(TemplateElement)
  templateElementsOk(_, _, []).
  templateElementsOk(s, s_pha, [element | tail]) :- {s_next}
    new s_next, s_next -P-> s,
    templateElementOk(s, s_next, s_pha, element),
    templateElementsOk(s_next, s_pha, tail).

  templateElementOk(s, _, _, Text(parts)) :-
    stringPartsOk(s, parts).

  templateElementOk(s, _, _,  XMLComment(_)).

  templateElementOk(s, _, _, XMLEmptyElement(_, attributes)) :-
    attributesOk(s, attributes).

  templateElementOk(s, _, _, XMLEmptyElementUnclosed(_, attributes)) :-
    attributesOk(s, attributes).

  templateElementOk(s, _, s_pha, XMLElement(openTagName, attributes, elements, closeTagName)) :-
    openTagName == closeTagName | error $[Opening and closing tag do not match],
    attributesOk(s, attributes),
    templateElementsOk(s, s_pha, elements).

  templateElementOk(s, _, _, JSElement(attributes, parts)) :-
    attributesOk(s, attributes),
    jsStringPartsOk(s, parts).

  templateElementOk(s, _, _, StyleElement(attributes, parts)) :-
    attributesOk(s, attributes),
    jsStringPartsOk(s, parts).

  jsStringPartsOk maps jsStringPartOk(*, list(*))
  jsStringPartOk : scope * JSPart
  jsStringPartOk(s, JSString(_)).
  jsStringPartOk(s, JSExp(exp)) :- typed(s, exp).

  templateElementOk(s, _, s_pha, IfTempl(c, then, else)) :-
    equalType(typeOfExp(s, c), bool(s)) | error $[Condition should be of type bool] @c,
    templateElementsOk(s, s_pha, then),
    templateElementsOk(s, s_pha, else).

  templateElementOk(s, _,  _, TemplateDefinition2TemplateElement(td)) :- nestedTemplateOk(s, td).

  templateElementOk(s, _, s_pha, SubmitElem(a, props, elems)) :-
    actionCallOrInlineOk(s, a),
    templatePropAssignmentsOk(s, props),
    templateElementsOk(s, s_pha, elems).

  templateElementOk(s, _, s_pha, SubmitLinkElem(a, props, elems)) :-
    actionCallOrInlineOk(s, a),
    templatePropAssignmentsOk(s, props),
    templateElementsOk(s, s_pha, elems).

  templateElementOk(s, _, s_pha, DownloadLink(a, props, elems)) :-
    actionCallOrInlineOk(s, a),
    templatePropAssignmentsOk(s, props),
    templateElementsOk(s, s_pha, elems).

  templateElementOk(s, _, s_pha, OutputImage(a, props, elems)) :-
    actionCallOrInlineOk(s, a),
    templatePropAssignmentsOk(s, props),
    templateElementsOk(s, s_pha, elems).

rules // expressions

  typeOfExp(s, TemplateName2Exp(TemplateName())) = string(s). // TO-DO: only allow this if inside a template

rules // loops

  templateElementOk(s, _, s_pha, For(x, srt, exp, OptFilterSome(f), elems, ForSeparator(separatorElems))) :- {s_for typeOfSort typeOfExp}
    typeOfSort == typeOfSort(s, srt),
    typeOfExp == typeOfExp(s, exp),
    or(
      equalTypeB(LIST(typeOfSort), typeOfExp),
      equalTypeB(SET(typeOfSort), typeOfExp)
    ) | error $[Must be a list or set of type [typeOfSort], [typeOfExp] given] @exp,
    new s_for, s_for -P-> s,
    forLoopFilterOk(s_for, f),
    forLoopOk(s_for, s_pha, x, typeOfSort, elems),
    separatorOk(s, s_pha, separatorElems),
    @x.type := typeOfSort.

  templateElementOk(s, _, s_pha, ForInferred(x, exp, OptFilterSome(f), elems, ForSeparator(separatorElems))) :- {s_for typeOfExp t}
    typeOfExp == typeOfExp(s, exp),
    t == stripGenericType(typeOfExp),
    new s_for, s_for -P-> s,
    forLoopFilterOk(s_for, f),
    forLoopOk(s_for, s_pha, x, t, elems),
    separatorOk(s, s_pha, separatorElems),
    @x.type := t.

  templateElementOk(s, _, s_pha, ForAll(x, srt, OptFilterSome(f), elems, ForSeparator(separatorElems))) :- {s_for typeOfSort}
    typeOfSort == typeOfSort(s, srt),
    new s_for, s_for -P-> s,
    forLoopFilterOk(s_for, f),
    forLoopOk(s_for, s_pha, x, typeOfSort, elems),
    separatorOk(s, s_pha, separatorElems),
    @x.type := typeOfSort.

  templateElementOk(s, _, s_pha, ForCount(x, fromExp, toExp, elems, ForSeparator(separatorElems))) :- {s_for intType}
    intType == int(s),
    equalType(typeOfExp(s, fromExp), intType) | error $[From expression should have type Int],
    equalType(typeOfExp(s, toExp)  , intType) | error $[To expression should have type Int],
    new s_for, s_for -P-> s,
    forLoopOk(s_for, s_pha, x, intType, elems),
    separatorOk(s, s_pha, separatorElems),
    @x.type := intType.

  forLoopOk : scope * scope * string * TYPE * list(TemplateElement)
  forLoopOk(s_for, s_pha, x, t, stmts) :-
    declareVar(s_for, x, t),
    declareAnnotation(s_for, x, DERIVED()), // abuse derived annotation to declare immutability of x
    templateElementsOk(s_for, s_pha, stmts).

  separatorOk : scope * scope * list(TemplateElement)
  separatorOk(s, s_pha, elems) :- {s_separator}
    new s_separator, s_separator -P-> s,
    templateElementsOk(s_separator, s_pha, elems).

rules // enforce correct order of template elements

  // correct order:
  // 1. var decls
  // 2. init block
  // 3. other template elements
  templateElementOrderOk : list(TemplateElement) * BOOL * BOOL
  templateElementOrderOk([], _, _).
  templateElementOrderOk([x | xs], _, _). // TO-DO: verify if we want this check :- templateElementOrderOk(xs, TRUE(), TRUE()).

  templateElementOrderOk([TEVarDecl(v) | xs], varDeclsDone, initDone) :-
    varDeclsDone == FALSE() | error $[Variable declarations must be at the start of a page or template] @v,
    templateElementOrderOk(xs, varDeclsDone, initDone).

  templateElementOrderOk([i@Init(_) | xs], _, initDone) :-
    initDone == FALSE() | error $[Init block must be between variable declarations and the rest of the page or template] @i,
    templateElementOrderOk(xs, TRUE(), initDone).

rules // template var args

  typeOfArg(s, Arg(_, TemplateVarArgSort(props))) = LIST(TEMPLATEVARARG(ts, s_arg)) :-
    new s_arg,
    ts == typesOfTemplateVarArgProps(s, s_arg, props).

  typesOfTemplateVarArgProps maps typeOfTemplateVarArgProp(*, *, list(*)) = list(*)
  typeOfTemplateVarArgProp : scope * scope * FormalVarArg -> TYPE
  typeOfTemplateVarArgProp(s, s_arg, FormalVarArg(x, srt)) = t :-
    t == typeOfSort(s, srt),
    declareVar(s_arg, x, t),
    optionallyDeclareTemplateElements(s_arg, x, t).

  optionallyDeclareTemplateElements : scope * string * TYPE
  optionallyDeclareTemplateElements(_, _, _).
  optionallyDeclareTemplateElements(s_arg, x, TEMPLATEELEMENTS()) :-
    declareTemplate(s_arg, x, []).

  typeOfProperty(s, TEMPLATEVARARG(_, s_arg), x) = t :-
    propertyType(s_arg, x) == t.

  templateCallOk_internal(s, s_pha, MemberTemplateCall(x, tc), ajax) :- { s_arg s_resolve }
    variableType(s, x) == TEMPLATEVARARG(_, s_arg) | error $[Variable [x] is not a template variable argument],
    new s_resolve, s_resolve -P-> s_arg,
    templateCallOk_internal(s_resolve, s_pha, tc, ajax).

  typeCompatibleB(TEMPLATEVARARG(ts1, _), TEMPLATEVARARG(ts2, _)) = b :-
    b == typesCompatible(ts1, ts2).

rules // utils

  rootPageDefined : scope * string
  rootPageDefined(s, errorLoc) :- { p ts }
    resolvePage(s, "root") == [(_, (_, PAGE(p, ts)))|_] | error $[No root page defined] @errorLoc,
    noRootPageArguments(p, ts).

  noRootPageArguments : string * list(TYPE)
  noRootPageArguments(_, []).
  noRootPageArguments(p, [_ | _]) :- false | error $[Root page is not allowed to have parameters] @p.

  typesOfTemplateArgs maps typeOfTemplateArg(*, list(*)) = list(*)
  typeOfTemplateArg : scope * TemplateArg -> (string * list(TYPE))
  typeOfTemplateArg(s, TemplateArg(x, argSorts)) = (x, typesOfSorts(s, argSorts)).

×