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);
}
}
