private void checkAccessors(EnumSet<Modifier> modifiers, AccessorDeclarationNode get, AccessorDeclarationNode set, SyntaxNode node) { if (get != null && set != null) { if (!get.Modifiers.isEmpty() && !set.Modifiers.isEmpty()) { context.addError(CompileErrorId.IllegalGetOrSetModifiers, node); } if ((get.Body == null) != (set.Body == null)) { context.addError(CompileErrorId.IllegalGetOrSetBody, node); } } else if (get != null) { if (!get.Modifiers.isEmpty()) { context.addError(CompileErrorId.IllegalGetOrSetModifiers, node); } if (!modifiers.contains(Modifier.Abstract) && get.Body == null) { context.addError(CompileErrorId.IllegalGetOrSetBody, node); } } else { if (!set.Modifiers.isEmpty()) { context.addError(CompileErrorId.IllegalGetOrSetModifiers, node); } if (!modifiers.contains(Modifier.Abstract) && set.Body == null) { context.addError(CompileErrorId.IllegalGetOrSetBody, node); } } }
private void setPropertyOrIndexerModifiers(AccessorDeclarationNode accessor, EnumSet<Modifier> propertyModifiers, MethodBuilder methodBuilder) { var protectionSet = false; var isFinal = true; var modifiers = accessor.Modifiers; foreach (var mod in modifiers) { switch (mod) { case Public: if (methodBuilder.IsPrivate || methodBuilder.IsProtected) { context.addError(CompileErrorId.PublicProtectedPrivate, accessor); } else { methodBuilder.setPublic(true); protectionSet = true; } break; case Private: if (methodBuilder.IsPublic || methodBuilder.IsProtected) { context.addError(CompileErrorId.PublicProtectedPrivate, accessor); } else { methodBuilder.setPrivate(true); protectionSet = true; } isFinal = false; break; case Protected: if (methodBuilder.IsPrivate || methodBuilder.IsPublic) { context.addError(CompileErrorId.PublicProtectedPrivate, accessor); } else { methodBuilder.setProtected(true); protectionSet = true; } break; default: context.addError(CompileErrorId.UnexpectedModifier, accessor, mod.toString().toLowerCase()); break; } } foreach (var mod in propertyModifiers) { switch (mod) { case Public: if (!protectionSet) { methodBuilder.setPublic(true); } break; case Private: if (methodBuilder.IsPublic || methodBuilder.IsProtected) { context.addError(CompileErrorId.PublicProtectedPrivate, accessor); } else { if (!protectionSet) { methodBuilder.setPrivate(true); } } break; case Protected: if (methodBuilder.IsPublic) { context.addError(CompileErrorId.PublicProtectedPrivate, accessor); } else { if (!protectionSet) { methodBuilder.setProtected(true); } } break; case Final: methodBuilder.setFinal(true); break; case Abstract: if (methodBuilder.IsFinal || methodBuilder.IsStatic) { context.addError(CompileErrorId.FinalAbstractStaticMethod, accessor); } else { methodBuilder.setAbstract(true); } isFinal = false; break; case Static: if (methodBuilder.IsAbstract) { context.addError(CompileErrorId.FinalAbstractStaticMethod, accessor); } else { methodBuilder.setStatic(true); } break; case Synchronized: methodBuilder.setSynchronized(true); break; case Native: methodBuilder.setNative(true); break; case Strictfp: methodBuilder.setStrict(true); break; case Virtual: case Override: isFinal = false; break; default: context.addError(CompileErrorId.UnexpectedModifier, accessor, mod.toString().toLowerCase()); break; } } methodBuilder.setFinal(isFinal); }
/// <inheritdoc/> public override void VisitAccessorDeclarationNode(AccessorDeclarationNode node) { // Types cannot be declared in an accessor, so we stop here }
private void parseAccessorDeclaration(IAccessorsOwner declaration, bool inInterface) { var accessor = new AccessorDeclarationNode(); while (lexicalUnit == LexicalUnit.OpenBracket) { accessor.Annotations.add(parseAnnotationSection()); } setScannerState(accessor); switch (lexicalUnit) { case Keyword: switch (scanner.Keyword) { case Protected: accessor.Modifiers.add(Modifier.Protected); nextLexicalUnit(true); break; case Private: accessor.Modifiers.add(Modifier.Private); nextLexicalUnit(true); break; } break; } switch (lexicalUnit) { case ContextualKeyword: switch (scanner.Keyword) { case Get: if (declaration.GetAccessor != null) { throw error(ParseErrorId.DuplicateAccessor); } declaration.GetAccessor = accessor; nextLexicalUnit(true); break; case Set: if (declaration.SetAccessor != null) { throw error(ParseErrorId.DuplicateAccessor); } declaration.SetAccessor = accessor; nextLexicalUnit(true); break; default: throw error(ParseErrorId.AccessorExpected); } break; default: throw error(ParseErrorId.AccessorExpected); } switch (lexicalUnit) { case SemiColon: accessor.EndPosition = scanner.EndPosition; nextLexicalUnit(false); break; case OpenBrace: if (!inInterface) { accessor.Body = parseBlockStatement(); accessor.EndPosition = accessor.Body.EndPosition; break; } goto default; default: throw error(ParseErrorId.SemiColonExpected); } }
private void fakeParseShortProperty(IAccessorsOwner declaration, Modifier setterAccess, bool inInterface) { var accessor = new AccessorDeclarationNode(); setScannerState(accessor); declaration.GetAccessor = accessor; accessor.EndPosition = scanner.EndPosition; if (!inInterface || setterAccess == Modifier.Public) { accessor = new AccessorDeclarationNode(); setScannerState(accessor); if (declaration.Modifiers.any(x => isLess(x, setterAccess))) accessor.Modifiers.add(setterAccess); declaration.SetAccessor = accessor; accessor.EndPosition = scanner.EndPosition; } }
// Types cannot be declared in an accessor, so we stop here public override void VisitAccessorDeclarationNode(AccessorDeclarationNode node) { }
private void print(AccessorDeclarationNode accessor, bool getter, int indent, StringBuilder sb) { var indentText = buildIndentText(indent + 1); foreach (var attr in accessor.Annotations) { sb.append(indentText); print(attr, true, sb); } sb.append(indentText); print(accessor.Modifiers, sb); if (getter) { sb.append("get"); } else { sb.append("set"); } if (accessor.Body == null) { sb.append(";\r\n"); } else { sb.append(" "); print(accessor.Body, indent + 1, sb); } }