Add a notation for static and runtime semantics attached to grammar productions.

[claudepache]

It concerns the phrases of the form "the result of evaluating production with argument arg", and "the result of performing Foo of production with argument arg", and variations thereof.

Possible notation (to be bikesheded):

Evaluation{production}(args)
Foo{production}(args)

etc.

That will allow to replace the majority of remaining ReturnIfAbrupt steps in the spec with the ? notation.

Issue of my proposal: we lose the editorial distinction between the uses of runtime semantics (marked with the action verbs "performing" and "evaluating") and the use of static semantics.

Examples from section 12.2.6.9:

Replace:

1. Let status be the result of performing PropertyDefinitionEvaluation of PropertyDefinitionList with arguments object and enumerable.
2. ReturnIfAbrupt(status).

with:

1. Perform ? PropertyDefinitionEvaluation{PropertyDefinitionList}(object, enumerable).

Replace:

1. Let propName be StringValue of IdentifierReference.
2. Let exprValue be the result of evaluating IdentifierReference.
3. Let propValue be ? GetValue(exprValue).

with:

1. Let propName be StringValue{IdentifierReference}().
2. Let exprValue be ? Evaluation{IdentifierReference}().
3. Let propValue be ? GetValue(exprValue).

Replace:

1. Let propKey be the result of evaluating PropertyName.
2. ReturnIfAbrupt(propKey).
3. Let exprValueRef be the result of evaluating AssignmentExpression.
4. Let propValue be ? GetValue(exprValueRef).

with:

1. Let propKey be ? Evaluation{PropertyName}().
2. Let exprValueRef be ? Evaluation{AssignmentExpression}().
3. Let propValue be ? GetValue(exprValueRef).

[claudepache]

Issue of my proposal: we lose the editorial distinction between the uses of runtime semantics (marked with the action verbs "performing" and "evaluating") and the use of static semantics.

Operations done at runtime should probably always be prefixed by either ? or !; that will restore that distinction.

[bterlson]

I would like a new syntactic convention here. But what about using method invocation syntax, namely:

PropertyName.Evaluation(), exprValueRef.GetValue(), etc?

[domenic]

I think when @bterlson explained this to me last it was important that they are really abstract methods, yeah. If that could be made more explicit, I'd be quite happy.

[jmdyck]

Bear in mind that the 'target' of such an invocation can't always be referenced simply by a nonterminal. E.g., consider:

    1. Let _falseRef_ be the result of evaluating the second |AssignmentExpression|.

Would that become

   1. Let _falseRef_ be (the second |AssignmentExpression|).Evaluation()

or

    1. Let _AE2_ be the second |AssignmentExpression|.
    2. Let _falseRef_ be _AE2_.Evaluation()

or (say)

    1. Let _falseRef_ be |AssignmentExpression|<sub>2</sub>.Evaluation()

(Also, the exprValueRef.GetValue() example is odd, because GetValue(V) is defined as an 'ordinary' abstract operation, not a syntax-discriminated operation.)