Issue 9250: Page 28
Issue 9251: Page 30
Issue 9252: Page 45 and 165
Issue 9253: Page 117
Issue 9254: Page 118
Issue 9255: Page 131
Issue 9379: Incorrect composition of variables in patterns
Issue 9380: Revise the encoding of primitive domains
Issue 9381: Bad navigability in cross-package links
Issue 9382: Typo error for properties whenOwner and whereOwner
Issue 9383: RelationalTransformation as a subclass of Transformation
Issue 9384: RelationalTransformation as a subclass of Transformation
Issue 9385: isTopLevel should not be a derived property
Issue 9386: Entry operations in operational definitions
Issue 9387: Typo error ImperativeIteratorExp expected in diagram
Issue 9388: Missing association from MappingParameter to a ModelParameter
Issue 9389: Missing variable references within inlined object expressions
Issue 9390: Missing iterator variable in resolve expressions
Issue 9391: Missing multiplicity of AnonymousLiteralPart::value
Issue 9392: When and where clause for mapping operations
Issue 9393: Inconsistency of multiplicity of ImperativeIterateExp::target
Issue 9394: Logging textual messages that depend on variables
Issue 9397: QVT Issue: Support for CMOF metamodels
Issue 9414: Section: 8/2
Issue 9415: Section: 7/11
Issue 9417: Section: 8/2
Issue 9418: Section: 8/2 page 79
Issue 9419: Section: 7/13
Issue 9420: Section: 8/1
Issue 9421: Section: 8/2 page 88
Issue 9422: Section: 8/2 page 95
Issue 9423: Section: 8/2 page 99
Issue 9424: Section: 8/3 page 110
Issue 9425: Section: 8/3 page 110 (02)
Issue 9426: Section: 8/3 page 110 (03)
Issue 9427: Section: A.2.2
Issue 9428: Section: 8/2 page 70
Issue 9429: Section: 8/2 page 79
Issue 9430: Section: 8/2 page 86
Issue 9431: Section: 8/2 page 91
Issue 9432: Section: 8/2 page 92
Issue 9433: Section: 8/2 page 93
Issue 9434: Section: 8/2 page 94
Issue 9435: Section: 8/2 page 95
Issue 9436: Section: 8/2
Issue 9437: Section: 8/2 page 97
Issue 9438: Section: 8/2 page 98
Issue 9439: Section: 8/2 page 99
Issue 9440: Section: 8/2 page 101
Issue 9441: Section: 8/2 page 102
Issue 9442: Section: 9/17 page 132
Issue 9443: Section: 9/17 page 134
Issue 9463: variable-assignment isn't defined in Core language
Issue 10077: QVTrelation to QVTcore transformation
Issue 10603: OCL extensions
Issue 10604: Comments
Issue 10605: Unquoted commas
Issue 10608: Missing commas
Issue 10609: Over-enthusiastic semicolon
Issue 10610: Unsafe oclExpressionCS
Issue 10611: Member selection as domain body
Issue 10612: Missing paramDeclaration
Issue 10613: Missing oclExpressionCSList
Issue 10614: Filename
Issue 10615: Member selection operator
Issue 10616: Ambiguity
Issue 10617: Typos
Issue 10618: Formatting
Issue 10619: Relation To Core Transformation
Issue 10624: Kind of expressions in collection patterns
Issue 10625: Escape characters in string literals
Issue 10626: Top-levelness in QVT relations need to be enforced by a constraint
Issue 10627: Rules for infering an extent
Issue 10644: Query result syntax
Issue 10645: RelationalCallExp missing
Issue 10647: Problem with Domain syntax
Issue 10648: Collection Type syntax ambiguities
Issue 10649: Identifiers syntax to avoid reserved keywords
Issue 10784: Relations language
Issue 10785: Relations language should support "default assignments"
Issue 10922: rules for solving type identifiers are missing in the QVTOperational syntax
Issue 10923: The BNF syntax of QVTOperational is not complete
Issue 10924: The representation and the containment of 'this' variable is missing
Issue 10925: Incomplete specification for the resolution operation ResolveExp
Issue 10926: Clarify the return type of xselect operator
Issue 10927: The QVT Operational StdLib has various mispellings and copy-paste errors
Issue 10928: Extent of intermediate classes in QVT Operational
Issue 10929: Distinguishing pure syntactic tags from other tags in QVTOperational
Issue 10949: 7.13.1 Scoped transformation name
Issue 10950: 7.13.1 Model class name semantics
Issue 10951: 7.13.1 Collection conversions
Issue 10952: 7.11.1.2 Meta-model Id persistence
Issue 10953: 7.11.2.3 CollectionTemplateExp
Issue 10954: 7.11.2.3 CollectionTemplateExp.referredCollectionType
Issue 10955: 7.13 Comments
Issue 10956: 7.13 Implicit Variable Declarations
Issue 10975: 8.4.6.2 QVToperational is not a syntax extension of OCL
Issue 10977: Find better notation for explicit extent indication in op mapping parameter
Issue 10978: QVTOperational examples have some errors and need to be inline with grammar
Issue 10979: Consider renaming 'AnonymousTuple' as 'OrderedTuple'
Issue 10984: 7.11.3.1 Relation.operationalImpl
Issue 10985: Chapter 7 QVTrelation Standard Library
Issue 10986: Chapter 7 Collection::=()
Issue 10987: Chapter 7,8,9 EssentialOCL usage
Issue 10988: Pre-ballot 2 FTF Appendix A: Erroneous collectionTemplate grammar
Issue 10989: Pre-ballot 2 FTF Appendix A: Erroneous memberSelection grammar
Issue 10990: 8.4.3.5 = and ==
Issue 10991: 8.4.3.5 != and <> UML 2 superstructure -- figure 9.4 is duplicate of figure 9.3
Issue 11022: Top-level constraint too restrictive
Issue 11023: Typos and omissions in the QVT operational Part
Issue 11024: Any used instead of MOF::Object in operational type extensions
Issue 11025: Missing text for notation for class properties in Section 8.4.6
Issue 11026: Some errors in BNF grammar of the operational part
Issue 11057: Missing notation to indicate the enforced direction in mapping operations
Issue 11059: Inconsistency in definition of TryExp with figure
Issue 11060: Consider adjusting the notation for unpack
Issue 11062: Argument list missing in raise expression
Issue 11063: Consider using the case keyword within swith expression
Issue 11064: Consider using the package keyword instead of metamodel
Issue 9250: Page 28 (mof-qvt-ftf)
Click here for this issue's archive.
Source: EDS (Ms. Susan Entwisle, susan.entwisle@eds.com)
Nature: Uncategorized Issue
Severity:
Summary:
states that the plugin has access to object references in models, and may do arbitrary things to those objects. The specification should state that this approach breaks encapsulation of the object.
Chapter 9 The Relations Language contains long and complex sentences, which reduce the readability of the specification
Unless some explicit replacement suggestions are provided it is difficult to solve this kind of editorial issue.
the naming and diagram conventions should be introduced before they are used in Section 9.11 and 11.7, respectively
Section 10.2.2.6 ForExp is missing from the class diagram in Section 10.2.2 The ImperativeOCL Package
ForExp is already present in Figure 8.4. Because there is no specific relation for this class there is no need to repeat its definition in another diagram.
Section 10.2.2.7 ImperativeIterateExp is missing from the class diagram in Section 10.2.2 The ImperativeOCL Package
Section 10.2.2.24 third sentence “In the perspective of the runtime environment a typedef is never instantiated” appears to be redundant as the same intent is expressed in second sentence “A typedef is never instantiated”
In QVTBase package, the association 'Pattern::bindsTo' cannot be composition since variables in relations specifications are owned by Relations and because variables can be bound to more than one pattern. The same applies for 'TemplateExp::Variable' in QVTRelation package which should not be a composition. Suggested resolution: Change the property definitions as: 'Pattern::bindsTo : [*] Variable opposites pattern [*]' 'TemplateExp::bindsTo : [0..1] Variable opposites pattern [*] If needed add OCL well-formedness in QVT Core to restrict multiplicity.
Primitive domains are simpler than other relation domains since they do are not dependent on a given typed model (primitive types are available to all metamodels) and there is no need to refer to a template expression. In QVTBase package, the multiplicity of Domain::typedModel should be '0..1' instead of '1' to avoid an arbitrary assignment to model typed model for the primitive diomain. In addition the multiplicity of RelationDomain-Pattern association should be changed to 0..1.
The reverse link from Transformation to Tag should become not navigable. Otherwise there is a dependency between EMOF and QVTBase packages. In the QVTOperational package the same stands for navigability: The opposite role 'owner' of Module::ownerTag The opposite role 'module' of Module::configProperty The opposite role 'tryBodyOwner' of TryExp::tryBody The opposite role 'computeOwner' of ComputeExp::returnedE
In the QVTBase diagram 'whenOwner' should be the opposite property of 'when' and 'whenOwner' the opposite property of when. Currently this is reverted.
To avoid dependency of QVTBase to QVTRelation due to the fact
that a relational transformation contains QVTRelation::Keys
Instances, the Transformation metaclass should be subtyped
within the QVTRelations package.
By the way, the association between relational transformations
and Keys is missing in the metamodel and need to be added.
Suggestion: Add a RelationalTransformation metaclass inheriting
from Transformation and add the missing association:
'RelationalTransformation::key : [*] Key {composes}'
Correct the type of OperationalTransformation:refined so that
it is a RelationalTransformation (instead of 'Transformation')
To avoid dependency of QVTBase to QVTRelation due to the fact
that a relational transformation contains QVTRelation::Keys
Instances, the Transformation metaclass should be subtyped
within the QVTRelations package.
By the way, the association between relational transformations
and Keys is missing in the metamodel and need to be added.
Suggestion: Add a RelationalTransformation metaclass inheriting
from Transformation and add the missing association:
'RelationalTransformation::key : [*] Key {composes}'
Correct the type of OperationalTransformation:refined so that
it is a RelationalTransformation (instead of 'Transformation')
For implementers discovering whether a relation is a top level relation may be nighmare. It would be preferible that this property be a "pain" property (not derived). This will be aligned with the concrete syntax where the 'top' keyword is explicitly set.
For models that have a well identified "root" element and type, it makes sence to designate a mapping operation on the root type to be the entry of the transformation. Currently this is not possible. Suggestion: Replace the 'OperationalTransformation::entry : EntryOperation' association by a more general 'Module::entry : Operation'
The diagram refers to a CollectorExp undefined class. In fact This class is the ImperativeIteratorExp found in the class description
Non primitive MappingParameters are related to ModelParameters but the the association is missing in the metamodel. Also, when The information cannot be infered from the parameter types there is no way to indicate this when using the textual syntax. Suggestion: Add the association 'MappingParameter::extent : [0..1] ModelParameter' For the concrete syntax, use the '@' character: mymappingparameter:MyType@mymodelparameter Usage of this notation should not be mandatory when the model type can be automatically infered from the parameter type.
Inlined ObjectExp have no explicit result variable. Nevertheless
An implicit variable is needed so that the representation of property
access within the body of ObjectExp is consistent.
These variables need to exist somewhere and so a container for these
implicit variables is needed.
Suggestion:
Adding the association:
OperationBody::variable : [*] Variable {composes}
And make the multiplicity of ObjectExp::referredObject equal to '1'
A resolution operator implies iteration over the list of objects transformed from a source element. However no iteration variiable is represented. Suggestion: Define ResolveExp as a subclass of ImperativeLoopExp. As a consequence, the field ResolveExp::condition can be removed (since already contained by ImperativeLoopExp)
The multiplicity of AnonymousLiteralPart::value is not indicated in the diagram. It should be equal to 1.
Reusing the 'when' and 'where' clauses of the refined relation of a mapping operation to represent the 'when' and 'where' clauses of the mapping operation is semantically not very accurate since there are some differencies. Should better have their own representation. Suggestion: add specifics MappingOperation::when and MappingOperation::where associations.
According to the class description the multiplicity of ImperativeIterateExp::target should be [0..1] not 1 in the diagram view.
He current representation of LogExp does not allow output messages that are variable dependent. This is not realistic. We should use here ordinary argument representation to encode The text of the message and the level. Suggestion: LogExp defined as a subclass of OperationCallExp. The 'text', 'level' and 'element' fields can therefore be removed since encoded as positional arguments.
The QVT spec (ptc/05-11-01) is littered with references to EMOF but has not one reference to CMOF. Hence it's not clear whether QVT can be used to transform models that instantiate CMOF metamodels. This is a major requirement since UML2 is itself a CMOF metamodel. Note that it's not important here that the QVT metamodel itself is expressed only in EMOF: but that it can be applied to CMOF metamodels. This means that references such as ObjectTemplateExp::referredClass(from EMOF) (see Fig 7.6) should also support references to CMOF metaclasses. Though CMOF is a compatible extension of EMOF, it is important that the QVT specification makes it clear that references to CMOF classes must be supported and that compliant QVT engines should not lose information when they transform models for CMOF metamodels. This is also likely to requires changes to the specification logic that describes the execution of transformations - for example to fully support non-unique Associations.
Typographic errors: - Character ń appears in several pages: 13, 14, 15, 17, 18, 22, ... - Bad indented in page 15: namespace = p:Package {}, in page 16: primaryKey = k:PrimaryKey {...} in page 22: c1: Class, a1: Attribute l1: attrs (c1, a1) in page 36: <varDeclaration>* in page 37: | (<oclExpressionCS> ';')* - At page 71: "...expressions that is executed is sequence." it should say: "...expressions that is executed in sequence." - At page 71: "He self variable..." it should say: "The self variable ..." - At page 78: "An explicit usage of the population ...required is certain situations ..." it should say: "An explicit usage of the population ...required in certain situations ..." - At page 91: "Tre endif keyword ..." it should say: "The endif keyword ..." - Bad format in page 22: 7.10.3.3 (see font of 7.10.3.2) in page 23: 7.10.3.4 (see font of 7.10.3.2) - In figure 7.4 (page 26) the class Domain must be written in italic. The class Domain is abstract. - In figure 7.4 (page 26) the class Rule must be written in italic. The class Rule is abstract. - In page 49 at expression: name:=self.name;type:=getSqlType(self.type) missing a space between name and type - At page 88: "...it has four pre-defined variants named xcollect..." it should say: "...it has five pre-defined variants named xcollect..." - At page 110: "...beginning and the end of the srings and..." it should say: "...beginning and the end of the strings and..." - At page 112: "...comment delimited by "--" and the end of file" it should say: "...comment delimited by "--" and the end of line" - At page 112: "...comment delimited by "//" and the end of file" it should say: "...comment delimited by "//" and the end of line"
CollectionKind not defined in this document in kind: CollectionKind
enforcedDirection not defined in this document enforcedDirection: ModelParameter [0..1]
isScoped not defined in this document in "Unless isScoped is true...". It should be isVirtual (see Figure 8.3)
Figure 16 does not exists In the first line at page 42: "...of relations. Figure 16 ..." must be Figure 7.13. Also, at same page: "The textual specification ... to Figure 16 is ..." must be Figure 7.13.
Pim2Psm or PimToPsm ? At page 57: "The example below ... Pim2Psm transformation ..." "transformation PimToPsm (...)"
ImperativeIterateExp should be named CollectorExp see Figures 8.4 and 8,5 (page 88)
BreakExp (8.2.2.16) and ContinueExp (8.2.2.17) at page 95 are missing in the Figures 8.5 and 8.6
BreakExp and ContinueExp are already defined in Figure 8.4. Because there are no additional properties for these classes, they are not repeated in the other figures.
In the class InstantiationExp, the associations (page 99) are missing. It should be (see Figure 5): argument: OclExpression [*] {composes, ordered} extent: Variable [0..1] instantiatedClass: Class [1]
The signature of String::lastToUpper (): String (page 110) is not sound with its definition. "Converts the first character in ..." it should say: "Converts the last character in ..."
The definition of String::replace operation (page 110) is incomplete: the operation return a new string (as in OCL 2) or return the string modified ?
The definition of String::unquotify operation (page 110) is incomplete: if the string s not exists at begin or at end ?
Errors in the A.2.2 Encapsulation Example (page 172) - The strings "private", "get_", "set_", "public" and "in" should be 'private', 'get_', 'set_', 'public' and 'in' - The operation upperFirst() should be written firstToUpper (see page 110)
Association result of the ImperativeOperation class should be (see figure 8.2) result: VarParameter [*] {composes, ordered} Association body of the ImperativeOperation class should be (see figure 8.2) body: OperationBody [0..1] {composes}
The attribute virtual of the ImperativeCallExp should be named (see Figure 8.3) isVirtual "...depending on the value of the strict Boolean property." it should say: "...depending on the value of the isStrict Boolean property." (see Figure 8.3) "The latter keyword is used when strict is true" it should say: "The latter keyword is used when isStrict is true" (see Figure 8.3)
Association returnedElement of the ComputeExp class should be (see figure 8.5) returnedElement : Variable [1]
Association elsePart of the SwitchExp class should be (see figure 8.5) elsePart: OclExpression [0..1]
the attribute withReturn of the VariableInitExp class should be named withResult (see Figure 8.6) "...is notated using ':=' if withReturn property..." it should say: "...is notated using ':=' if withResult property..." (see Figure 8.6) "...uses '::=' if withReturn is true." it should say: "...uses '::=' if withResult is true." (see Figure 8.6)
Association value of the AssignExp class should be (see figure 8.6) value: OclExpression [*] {composes} Association left of the AssignExp class should be (see figure 8.6) left: OclExpression [1] {composes} Association defaultValue of the AssignExp class should be (see figure 8.6) defaultValue: OclExpression [0..1] {composes} Association item of the UnlinkExp class should be (see figure 8.6) item: OclExpression [1] {composes}
Association target of the UnlinkExp class should be (see figure 8.6) target: OclExpression [1] {composes} Association tryBody of the TryExp class should be (see figure 8.6) tryBody: OclExpression [1] {composes} Association exceptBody of the TryExp class should be (see figure 8.6) exceptBody: OclExpression [0..1] {composes}
Association value of the ReturnExp class should be (see figure 8.6) value: OclExpression [1] {composes}
Association assertion of the AssertExp class should be (see figure 8.6) assertion: OclExpression [1] {composes} Association log of the AssertExp class should be (see figure 8.6) log: LogExp [0..1] {composes}
Association element of the TupleExp class should be (see figure 8.6) element: OclExpression [1..*] {composes} Association variable of the UnpackExp class should be (see figure 8.6) variable: Variable [1..*] {composes}
Association variable of the UnpackExp class should be (see figure 8.6) variable: Variable [1..*] {composes}
Association condition of the Typedef class should be (see figure 8.7) condition: OclExpression [1] {composes}
Association elementType of the AnonymousTupleType class should be (see figure 8.7) elementType: Type [*] Association part of the DictLiteralExp class should be (see figure 8.7) part: DicLiteralPart [*] {composes}
The {ordered} constraint is in fact mising in the figure.Association part of the AnonymousTupleLiteralExp class should be (see figure 8.7) part: AnonymousTupleLiteralPart [*] {composes, ordered}
Association local of the Mapping class should be (see figure 9.2) local: Mapping [*]
Association slotExpression of the Assignment class should be (see figure 9.3) slotExpression: OclExpression [1] {composes} Association value of the Assignment class should be (see figure 9.3) value: OclExpression [1] {composes}
There exist assignments to variables in the QVT examples. However, variable-assignment is not defined in the abstract and concrete syntax of the Core language. This should be fixed. Impact: only changes the QVT Core language definition.
I've started looking at implementing QVTrelation->QVTcore in UMLX, but instantly hit problems. Since UMLX has built in type checking it identifies that: in RelationToTraceclass RelationDomain has a DomainPattern rather than an ObjectTemplateExp in SubTemplateToTraceClassProps ObjectTemplateExp has a PartTemplateItem rather than an ObjectTemplateExp These are easily fixed, but in TopLevelRelationToMappingForEnforcement there are too many discrepancies to resolve without major study; I'm very puzzled by the use of Sets for individual elements. Is there a revised draft that the FTF are working on that is any more consistent? FYI, I enclose the first two transformations in UMLX. I think they're a bit more intelligible, type consistent, although there a fair few UMLX loose ends to sort out.
I've started writing a QVTr parser. So far it just does syntax analysis.
It highlights a number of significant issues in the grammar and enables
many mistakes to be removed from the Relations to Core example.
OCL extension
-------------
7.13 should enumerate the new keywords:
checkonly
domain
enforce
extends
implementedBy
import
key
overrides
primitive
query
relation
top
transformation
when
where
and stress that they are not reserved words and so may appear in identifier. At least I presume this is the intent, since 'domain'
is used in the Relation To Core example. I'm not entirely sure that a domain called OclAny is unambiguous, and is one called self
useful?
The OCL and consequently the QVT syntax lack formality here.
OCL extensionsThe Relation To Core example uses a // comment, whereas OCL uses --. If this is intended then the OCL grammar must be extended
An unquoted comma is redundant in the BNF, so presumably the commas should quoted:
Replace: <modelDecl> ::= <modelId> ':' <metaModelId> (, <metaModelId>)*
By: <modelDecl> ::= <modelId> ':' <metaModelId> (',' <metaModelId>)*
Replace: <keyDecl> ::= 'key' <classId> '{' <propertyId> (, <propertyId>)* '}' ';'
By: <keyDecl> ::= 'key' <classId> '{' <propertyId> (',' <propertyId>)* '}' ';'
Replace: <varDeclaration> ::= <identifier> (, <identifier>)* ':' <typeCS> ';'
By: <varDeclaration> ::= <identifier> (',' <identifier>)* ':' <typeCS> ';'
List of propertyTemplate are used without separators. The Relation To Core example uses a comma separator.
In <domain>
Replace: <propertyTemplate>*
By: (<propertyTemplate> (',' <propertyTemplate>)*)
In <objectTemplate>
Replace: <propertyTemplate>*
By: (<propertyTemplate> (',' <propertyTemplate>)*)
The Relation To Core example omits trailing semicolons following a brace-termated domain. In <domain> Replace: ['implementedby' <OperationCallExpCS>] ';' By: ['implementedby' <OperationCallExpCS> ';']
The extension to oclExpressionCS affects all cases where OCL expressions are invoked. Since the "| (<oclExpressionCS> ';')*" term
covers epsilon, this introduces near catastrophic parsing ambiguities and meaningless syntax for existing usage.
Suggest: restrict the semi-colon separated extension to the extended syntax where it has useful semantic meaning. Permitting the
final semi-colon to be omitted seem needlessly generous/confusing/complicated. Therefore:
Replace: <oclExpressionCS> ::= <propertyCallExpCS>
| <variableExpCS>
| <literalExpCS>
| <letExpCS>
| <ifExpCS>
| <template>
| '(' <oclExpressionCS> ')'
| (<oclExpressionCS> ';')*
By: <oclExpressionCS> ::= <propertyCallExpCS>
| <variableExpCS>
| <literalExpCS>
| <letExpCS>
| <ifExpCS>
| <template>
| '(' <oclExpressionCS> ')'
<oclStatementCS> ::= (<oclExpressionCS> ';')*
and use this new construct as:
Replace: <when> ::= 'when' '{' <oclExpressionCS> '}'
By: <when> ::= 'when' '{' <oclStatementCS> '}'
Replace: <where> ::= 'where' '{' <oclExpressionCS> '}'
By: <where> ::= 'where' '{' <oclStatementCS> '}'
In <domain>
Replace: '{' <propertyTemplate>* '}' [ '{' <oclExpressionCS> '}' ]
By: '{' <propertyTemplate>* '}' [ '{' <oclStatementCS> '}' ]
In <query>
Replace: ';' | '{' <oclExpressionCS> '}'
By: ';' | '{' <oclStatementCS> '}'
Relations to Core uses a top of domain memberSelectionExprCS.
In <dommain>
Replace: '{' <propertyTemplate>* '}'
By: '{' (<propertyTemplate>* | memberSelectionExprCS) '}'
Or rather: '{' ((<propertyTemplate> (',' <propertyTemplate>)*) | memberSelectionExprCS) '}'
Suggest: <paramDeclaration> ::= <identifier> ':' <typeCS>
Sole usage in collectionTemplate is as list of list, so presumably a typo
Replace: <oclExpressionCSList> (',' <oclExpressionCSList>)*
By: <oclExpressionCS> (',' <oclExpressionCS>)*
However I cannot get past syntax ambiguities here between the '|' in a setComprehensionExpression
and the '|' in an oclExpression. To get Relations to Core to parse I just do:
Replace: <oclExpressionCSList> (',' <oclExpressionCSList>)*
By: <templateCS>
Surely this should be a URI? Even if it is a filename no OS can cope without dots, slashes or ... Replace: <filename> ::= <identifier> By: <filename> ::= StringLiteralExpCS
With -- as an OCL comment, ++ seems a very unfortunate choice of operator spelling. It also has minimal similarity to the C/Java increment operator which is unary. Please review. The usage seems to always be <big-clause> ++ <tiny>, so how about just a word. ?? <big-clause> 'in' <tiny> ?? <big-clause> 'over' <tiny> ?? <big-clause> 'forall' <tiny>
Replace: objectTemplate ::= [<identifier>] ':' <typeCS> '{'
By: <objectTemplate> ::= [<identifier>] ':' (primitiveTypeCS | tupleTypeCS | pathNameCS) '{'
excluding collectionType that is ambiguous wrt collectionTemplate syntax
In <domain> Replace: ['implementedby' <OperationCallExpCS>] By: ['implementedby' <operationCallExpCS>]
Inconsistent font for first line of 7.13.1.
After adjusting the syntax as above to match the author's apparent expectation, syntax checking reveals 69 problems, marked up with --** in the attached. (Surprisingly few for a new language that has clearly not had a machine-assisted check before.)
not an issue
The 'kind' property in collection template expression is not meant to specify Set/Bag/Sequence. It is meant to specify the kind of expression used in the collection pattern. Note: This issue is related to issue 9415. Suggested resolution: In order to avoid name clash with Ocl rename CollectionKind to CollectionPatternKind. IN section 7.11.2 insert the enumeration type CollectionPatternKind with the following definition: """ CollectionPatternKind The enumeration type that specifies the kind of pattern expression used to specify the collection pattern. Possible values are: Enumeration, Comprehension and MemberSelection.
The escape characters used in string literals need to be adequately defined or referenced. Note: This issue is related to issue: 9427