Skip to content

Commit

Permalink
Merge pull request #36495 from ushirask/annot-tuple-each-type
Browse files Browse the repository at this point in the history 
Add parser changes to allow annotations for each member in a tuple
  • Loading branch information
@MaryamZi
MaryamZi authored Aug 4, 2022
2 parents 8180716 + 65ea49b commit 44c492d
Show file tree
Hide file tree
Showing 57 changed files with 4,627 additions and 779 deletions.
4 changes: 3 additions & 1 deletion ...ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/parser/BLangNodeBuilder.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -111,6 +111,7 @@
import io.ballerina.compiler.syntax.tree.MarkdownParameterDocumentationLineNode;
import io.ballerina.compiler.syntax.tree.MatchClauseNode;
import io.ballerina.compiler.syntax.tree.MatchStatementNode;
import io.ballerina.compiler.syntax.tree.MemberTypeDescriptorNode;
import io.ballerina.compiler.syntax.tree.MetadataNode;
import io.ballerina.compiler.syntax.tree.MethodCallExpressionNode;
import io.ballerina.compiler.syntax.tree.MethodDeclarationNode;
Expand Down Expand Up @@ -995,7 +996,8 @@ public BLangNode transform(TupleTypeDescriptorNode tupleTypeDescriptorNode) {
RestDescriptorNode restDescriptor = (RestDescriptorNode) node;
tupleTypeNode.restParamType = createTypeNode(restDescriptor.typeDescriptor());
} else {
tupleTypeNode.memberTypeNodes.add(createTypeNode(node));
MemberTypeDescriptorNode member = (MemberTypeDescriptorNode) node;
tupleTypeNode.memberTypeNodes.add(createTypeNode(member.typeDescriptor()));
}
}
tupleTypeNode.pos = getPosition(tupleTypeDescriptorNode);
Expand Down
4 changes: 3 additions & 1 deletion ...-parser/src/main/java/io/ballerina/compiler/internal/diagnostics/DiagnosticErrorCode.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -345,7 +345,9 @@ public enum DiagnosticErrorCode implements DiagnosticCode {
ERROR_INVALID_BINDING_PATTERN("BCE0677", "error.invalid.binding.pattern"),
ERROR_RESOURCE_PATH_CANNOT_BEGIN_WITH_SLASH("BCE0678", "error.resource.path.cannot.begin.with.slash"),
REST_PARAMETER_CANNOT_BE_INCLUDED_RECORD_PARAMETER("BCE0679",
"error.rest.parameter.cannot.be.included.record.parameter")
"error.rest.parameter.cannot.be.included.record.parameter"),
ERROR_ANNOTATIONS_NOT_ALLOWED_FOR_TUPLE_REST_DESCRIPTOR("BCE0680",
"error.annotations.not.allowed.for.tuple.rest.descriptor"),
;

String diagnosticId;
Expand Down
98 changes: 61 additions & 37 deletions ...ballerina-parser/src/main/java/io/ballerina/compiler/internal/parser/BallerinaParser.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8396,8 +8396,8 @@ private boolean isUnaryOperator(SyntaxKind kind) {
* Parse array type descriptor.
* <p>
* <code>
* array-type-descriptor := member-type-descriptor [ [ array-length ] ]
* member-type-descriptor := type-descriptor
* array-type-descriptor := array-member-type-descriptor [ [ array-length ] ]
* array-member-type-descriptor := type-descriptor
* array-length :=
* int-literal
* | constant-reference-expr
Expand Down Expand Up @@ -11324,14 +11324,15 @@ private boolean isEndOfAnonFuncParametersList(SyntaxKind tokenKind) {
* tuple-member-type-descriptors := member-type-descriptor (, member-type-descriptor)* [, tuple-rest-descriptor]
* | [ tuple-rest-descriptor ]
* <br/><br/>
* member-type-descriptor := [annots] type-descriptor
* tuple-rest-descriptor := type-descriptor ...
* </code>
*
* @return
*/
private STNode parseTupleTypeDesc() {
STNode openBracket = parseOpenBracket();
startContext(ParserRuleContext.TYPE_DESC_IN_TUPLE);
startContext(ParserRuleContext.TUPLE_MEMBERS);
STNode memberTypeDesc = parseTupleMemberTypeDescList();
STNode closeBracket = parseCloseBracket();
endContext();
Expand All @@ -11358,49 +11359,49 @@ private STNode parseTupleMemberTypeDescList() {
}

// Parse first typedesc, that has no leading comma
STNode typeDesc = parseTypeDescriptor(ParserRuleContext.TYPE_DESC_IN_TUPLE);

STNode typeDesc = parseTupleMember();
return parseTupleTypeMembers(typeDesc, typeDescList);
}

private STNode parseTupleTypeMembers(STNode typeDesc, List<STNode> typeDescList) {
typeDesc = parseComplexTypeDescriptor(typeDesc, ParserRuleContext.TYPE_DESC_IN_TUPLE, false);

STNode tupleMemberRhs = parseTypeDescInTupleRhs();
if (tupleMemberRhs != null) {
typeDesc = STNodeFactory.createRestDescriptorNode(typeDesc, tupleMemberRhs);
}

private STNode parseTupleTypeMembers(STNode firstMember, List<STNode> memberList) {
STNode tupleMemberRhs;
// Parse the remaining type descs
while (!isEndOfTypeList(peek().kind)) {
if (typeDesc.kind == SyntaxKind.REST_TYPE) {
typeDesc = invalidateTypeDescAfterRestDesc(typeDesc);
if (firstMember.kind == SyntaxKind.REST_TYPE) {
firstMember = invalidateTypeDescAfterRestDesc(firstMember);
break;
}

tupleMemberRhs = parseTupleMemberRhs();
if (tupleMemberRhs == null) {
break;
}

typeDescList.add(typeDesc);
typeDescList.add(tupleMemberRhs);
typeDesc = parseMemberDescriptor();
memberList.add(firstMember);
memberList.add(tupleMemberRhs);
firstMember = parseTupleMember();
}

typeDescList.add(typeDesc);
return STNodeFactory.createNodeList(typeDescList);
memberList.add(firstMember);
return STNodeFactory.createNodeList(memberList);
}

private STNode parseMemberDescriptor() {
private STNode parseTupleMember() {
STNode annot = parseOptionalAnnotations();
STNode typeDesc = parseTypeDescriptor(ParserRuleContext.TYPE_DESC_IN_TUPLE);
STNode tupleMemberRhs = parseTypeDescInTupleRhs();
return createMemberOrRestNode(annot, typeDesc);
}

private STNode createMemberOrRestNode(STNode annot, STNode typeDesc) {
STNode tupleMemberRhs = parseTypeDescInTupleRhs();
if (tupleMemberRhs != null) {
if (!((STNodeList) annot).isEmpty()) {
typeDesc = SyntaxErrors.cloneWithLeadingInvalidNodeMinutiae(typeDesc, annot,
DiagnosticErrorCode.ERROR_ANNOTATIONS_NOT_ALLOWED_FOR_TUPLE_REST_DESCRIPTOR);
}
return STNodeFactory.createRestDescriptorNode(typeDesc, tupleMemberRhs);
}

return typeDesc;
return STNodeFactory.createMemberTypeDescriptorNode(annot, typeDesc);
}

private STNode invalidateTypeDescAfterRestDesc(STNode restDescriptor) {
Expand All @@ -11411,7 +11412,7 @@ private STNode invalidateTypeDescAfterRestDesc(STNode restDescriptor) {
}

restDescriptor = SyntaxErrors.cloneWithTrailingInvalidNodeMinutiae(restDescriptor, tupleMemberRhs, null);
restDescriptor = SyntaxErrors.cloneWithTrailingInvalidNodeMinutiae(restDescriptor, parseMemberDescriptor(),
restDescriptor = SyntaxErrors.cloneWithTrailingInvalidNodeMinutiae(restDescriptor, parseTupleMember(),
DiagnosticErrorCode.ERROR_TYPE_DESC_AFTER_REST_DESCRIPTOR);
}

Expand Down Expand Up @@ -16975,9 +16976,14 @@ private STNode parseStatementStartsWithOpenBracket(STNode annots, boolean isRoot

switch (currentNodeType) {
case TUPLE_TYPE_DESC:
member = parseComplexTypeDescriptor(member, ParserRuleContext.TYPE_DESC_IN_TUPLE, false);
member = createMemberOrRestNode(STNodeFactory.createEmptyNodeList(), member);
// If the member type was figured out as a tuple-type-desc member, then parse the
// remaining members as tuple type members and be done with it.
return parseAsTupleTypeDesc(annots, openBracket, memberList, member, isRoot);
case MEMBER_TYPE_DESC:
case REST_TYPE:
return parseAsTupleTypeDesc(annots, openBracket, memberList, member, isRoot);
case LIST_BINDING_PATTERN:
// If the member type was figured out as a binding pattern, then parse the
// remaining members as binding patterns and be done with it.
Expand Down Expand Up @@ -17084,6 +17090,8 @@ private STNode parseStatementStartBracketedListMember(List<STNode> qualifiers) {
return parseTypeDescOrExpr(qualifiers);
case FUNCTION_KEYWORD:
return parseAnonFuncExprOrFuncTypeDesc(qualifiers);
case AT_TOKEN:
return parseTupleMember();
default:
if (isValidExpressionStart(nextToken.kind, 1)) {
reportInvalidQualifierList(qualifiers);
Expand Down Expand Up @@ -17154,7 +17162,12 @@ private STNode parseTupleTypeDescOrListConstructor(STNode annots, STNode openBra
// If the member type was figured out as a list constructor, then parse the
// remaining members as list constructor members and be done with it.
return parseAsListConstructor(openBracket, memberList, member, isRoot);
case REST_TYPE:
case MEMBER_TYPE_DESC:
return parseAsTupleTypeDesc(annots, openBracket, memberList, member, isRoot);
case TUPLE_TYPE_DESC:
member = parseComplexTypeDescriptor(member, ParserRuleContext.TYPE_DESC_IN_TUPLE, false);
member = createMemberOrRestNode(STNodeFactory.createEmptyNodeList(), member);
// If the member type was figured out as a tuple-type-desc member, then parse the
// remaining members as tuple type members and be done with it.
return parseAsTupleTypeDesc(annots, openBracket, memberList, member, isRoot);
Expand Down Expand Up @@ -17217,6 +17230,8 @@ private STNode parseTupleTypeDescOrListConstructorMember(STNode annots) {
return parseExpression(false);
case OPEN_PAREN_TOKEN:
return parseTypeDescOrExpr();
case AT_TOKEN:
return parseTupleMember();
default:
if (isValidExpressionStart(nextToken.kind, 1)) {
return parseExpression(false);
Expand Down Expand Up @@ -17262,7 +17277,7 @@ private STNode parseTupleTypeDescOrListConstructorRhs(STNode openBracket, List<S
}

// Treat everything else as tuple type desc
STNode memberTypeDescs = STNodeFactory.createNodeList(getTypeDescList(members));
STNode memberTypeDescs = STNodeFactory.createNodeList(getTupleMemberList(members));
STNode tupleTypeDesc =
STNodeFactory.createTupleTypeDescriptorNode(openBracket, memberTypeDescs, closeBracket);
tupleTypeOrListConst =
Expand Down Expand Up @@ -17300,9 +17315,11 @@ private STNode parseStmtStartsWithTupleTypeOrExprRhs(STNode annots, STNode tuple

private STNode parseAsTupleTypeDesc(STNode annots, STNode openBracket, List<STNode> memberList, STNode member,
boolean isRoot) {
memberList = getTypeDescList(memberList);
memberList = getTupleMemberList(memberList);
startContext(ParserRuleContext.TUPLE_MEMBERS);
STNode tupleTypeMembers = parseTupleTypeMembers(member, memberList);
STNode closeBracket = parseCloseBracket();
endContext();

STNode tupleType = STNodeFactory.createTupleTypeDescriptorNode(openBracket, tupleTypeMembers, closeBracket);
STNode typeDesc =
Expand Down Expand Up @@ -17374,7 +17391,6 @@ private SyntaxKind getStmtStartBracketedListType(STNode memberNode) {
case ERROR_BINDING_PATTERN:
return SyntaxKind.LIST_BINDING_PATTERN;
case QUALIFIED_NAME_REFERENCE: // a qualified-name-ref can only be a type-ref
case REST_TYPE:
return SyntaxKind.TUPLE_TYPE_DESC;
case LIST_CONSTRUCTOR:
case MAPPING_CONSTRUCTOR:
Expand All @@ -17394,6 +17410,10 @@ private SyntaxKind getStmtStartBracketedListType(STNode memberNode) {
return SyntaxKind.LIST_CONSTRUCTOR;
case INDEXED_EXPRESSION:
return SyntaxKind.TUPLE_TYPE_DESC_OR_LIST_CONST;
case MEMBER_TYPE_DESC:
return SyntaxKind.MEMBER_TYPE_DESC;
case REST_TYPE:
return SyntaxKind.REST_TYPE;
default:
if (isExpression(memberNode.kind) && !isAllBasicLiterals(memberNode) && !isAmbiguous(memberNode)) {
return SyntaxKind.LIST_CONSTRUCTOR;
Expand Down Expand Up @@ -17509,8 +17529,8 @@ private STNode parseStatementStartBracketedListRhs(STNode annots, STNode openBra
}

switchContext(ParserRuleContext.TYPE_DESC_IN_TYPE_BINDING_PATTERN);
startContext(ParserRuleContext.TYPE_DESC_IN_TUPLE);
STNode memberTypeDescs = STNodeFactory.createNodeList(getTypeDescList(members));
startContext(ParserRuleContext.TUPLE_MEMBERS);
STNode memberTypeDescs = STNodeFactory.createNodeList(getTupleMemberList(members));
STNode tupleTypeDesc =
STNodeFactory.createTupleTypeDescriptorNode(openBracket, memberTypeDescs, closeBracket);
endContext(); // end tuple typ-desc
Expand All @@ -17525,7 +17545,7 @@ private STNode parseStatementStartBracketedListRhs(STNode annots, STNode openBra
if (!isRoot) {
// if this is a member, treat as type-desc.
// TODO: handle expression case.
memberTypeDescs = STNodeFactory.createNodeList(getTypeDescList(members));
memberTypeDescs = STNodeFactory.createNodeList(getTupleMemberList(members));
tupleTypeDesc =
STNodeFactory.createTupleTypeDescriptorNode(openBracket, memberTypeDescs, closeBracket);
endContext();
Expand Down Expand Up @@ -18537,14 +18557,18 @@ private STNode mergeQualifiedNameWithTypeDesc(STNode qualifiedName, STNode typeD
}

// ---------------------- Convert ambiguous nodes to a specific node --------------------------

private List<STNode> getTypeDescList(List<STNode> ambiguousList) {
List<STNode> typeDescList = new ArrayList<>();
private List<STNode> getTupleMemberList(List<STNode> ambiguousList) {
List<STNode> tupleMemberList = new ArrayList<>();
for (STNode item : ambiguousList) {
typeDescList.add(getTypeDescFromExpr(item));
if (item.kind == SyntaxKind.COMMA_TOKEN) {
tupleMemberList.add(item);
} else {
tupleMemberList.add(STNodeFactory.createMemberTypeDescriptorNode(STNodeFactory.createEmptyNodeList(),
getTypeDescFromExpr(item)));
}
}

return typeDescList;
return tupleMemberList;
}

/**
Expand Down Expand Up @@ -18582,7 +18606,7 @@ private STNode getTypeDescFromExpr(STNode expression) {
case LIST_BP_OR_LIST_CONSTRUCTOR:
case TUPLE_TYPE_DESC_OR_LIST_CONST:
STAmbiguousCollectionNode innerList = (STAmbiguousCollectionNode) expression;
STNode memberTypeDescs = STNodeFactory.createNodeList(getTypeDescList(innerList.members));
STNode memberTypeDescs = STNodeFactory.createNodeList(getTupleMemberList(innerList.members));
return STNodeFactory.createTupleTypeDescriptorNode(innerList.collectionStartToken, memberTypeDescs,
innerList.collectionEndToken);
case BINARY_EXPRESSION:
Expand Down
Loading

0 comments on commit 44c492d

Please sign in to comment.