// test ok void processEntiry(EntityDeclaration ed, TEntity te) { if (ed.HasModifier(Modifiers.Public)) { te.isPublic = true; } if (ed.HasModifier(Modifiers.Private)) { te.isPrivate = true; } if (ed.HasModifier(Modifiers.Internal)) { te.isInternal = true; } if (ed.HasModifier(Modifiers.Override)) { te.isOverride = true; } if (ed.HasModifier(Modifiers.Static)) { te.isStatic = true; } te.name = ed.Name; te.type = ed.ReturnType.GetText(); foreach (var attr in ed.Attributes) { te.attributes += attr.GetText(); } }
void CheckVirtual(EntityDeclaration entity) { if (!curType.Peek().HasModifier(Modifiers.Static) && !curType.Peek().HasModifier(Modifiers.Sealed) && entity.HasModifier(Modifiers.Virtual)) { if (!entity.HasModifier(Modifiers.Public) && !entity.HasModifier(Modifiers.Protected) && !entity.HasModifier(Modifiers.Internal)) { AddIssue( entity.NameToken, ctx.TranslateString("'virtual' members can't be private") ); return; } } if (!curType.Peek().HasModifier(Modifiers.Sealed) || !entity.HasModifier(Modifiers.Virtual)) { return; } AddIssue( entity.ModifierTokens.First(t => t.Modifier == Modifiers.Virtual), ctx.TranslateString("'virtual' modifier is not usable in a sealed class"), ctx.TranslateString("Remove 'virtual' modifier"), s => { s.ChangeModifier(entity, entity.Modifiers & ~Modifiers.Virtual); } ); }
void CheckNode(EntityDeclaration node) { if (!node.HasModifier(Modifiers.Override)) { return; } var type = node.Parent as TypeDeclaration; if (type == null || !type.HasModifier(Modifiers.Sealed)) { return; } foreach (var token_ in node.ModifierTokens) { var token = token_; if (token.Modifier == Modifiers.Sealed) { AddIssue(new CodeIssue( token, ctx.TranslateString("Keyword 'sealed' is redundant in sealed classes."), ctx.TranslateString("Remove redundant 'sealed' modifier"), script => script.ChangeModifier(node, node.Modifiers & ~Modifiers.Sealed) ) { IssueMarker = IssueMarker.GrayOut }); } } }
void CheckStaticRequired(EntityDeclaration entity) { if (!curType.Peek().HasModifier(Modifiers.Static) || entity.HasModifier(Modifiers.Static) || entity.HasModifier(Modifiers.Const)) { return; } var fd = entity as FieldDeclaration; if (fd != null) { foreach (var init in fd.Variables) { AddStaticRequiredError(entity, init.NameToken); } return; } var ed = entity as EventDeclaration; if (ed != null) { foreach (var init in ed.Variables) { AddStaticRequiredError(entity, init.NameToken); } return; } AddStaticRequiredError(entity, entity.NameToken); }
static bool GetAccessibility(EntityDeclaration element, out Accessibility acc) { if (element.Parent is TypeDeclaration && ((TypeDeclaration)element.Parent).ClassType == ClassType.Interface) { acc = Accessibility.Public; return(true); } bool result = false; acc = Accessibility.Private; if (element is TypeDeclaration && !(element.Parent is TypeDeclaration)) { acc = Accessibility.Internal; } if (element.HasModifier(Modifiers.Public)) { acc = Accessibility.Public; result = true; } else if (element.HasModifier(Modifiers.Private)) { acc = Accessibility.Private; result = true; } else if (element.HasModifier(Modifiers.Protected | Modifiers.Internal)) { acc = Accessibility.ProtectedOrInternal; result = true; } else if (element.HasModifier(Modifiers.Protected)) { acc = Accessibility.Protected; result = true; } else if (element.HasModifier(Modifiers.Internal)) { acc = Accessibility.Internal; result = true; } return(result); }
void Check(EntityDeclaration entity) { if (!entity.HasModifier(Modifiers.Override)) { return; } var rr = ctx.Resolve(entity) as MemberResolveResult; if (rr == null || rr.IsError) { return; } var method = rr.Member as IParameterizedMember; if (method == null) { return; } var baseMethod = InheritanceHelper.GetBaseMember(method) as IParameterizedMember; if (baseMethod == null) { return; } for (int i = 0; i < Math.Min(method.Parameters.Count, baseMethod.Parameters.Count); i++) { var arg = method.Parameters[i]; var baseArg = baseMethod.Parameters[i]; if (arg.Name != baseArg.Name) { int _i = i; var parameters = entity.GetChildrenByRole(Roles.Parameter); AddIssue(new CodeIssue( parameters.ElementAt(_i).NameToken, ctx.TranslateString("Parameter name differs in base method declaration"), string.Format(ctx.TranslateString("Rename to '{0}'"), baseArg.Name), s => { s.Rename(arg, baseArg.Name); } )); } } }
protected virtual void EmitMethodParameters(IEnumerable <ParameterDeclaration> declarations, AstNode context, bool skipCloseParentheses = false) { this.WriteOpenParentheses(); bool needComma = false; EntityDeclaration entityDeclaration = context as EntityDeclaration; if (entityDeclaration != null) { if (!entityDeclaration.HasModifier(Modifiers.Static)) { this.WriteThis(); if (declarations.Any()) { this.WriteComma(); } } } foreach (ParameterDeclaration p in declarations) { string name = p.Name; name = name.Replace(Bridge.Translator.Emitter.FIX_ARGUMENT_NAME, ""); if (this.Emitter.LocalsNamesMap != null && this.Emitter.LocalsNamesMap.ContainsKey(name)) { name = this.Emitter.LocalsNamesMap[name]; } if (needComma) { this.WriteComma(); } needComma = true; this.Write(name); } if (!skipCloseParentheses) { this.WriteCloseParentheses(); } }
public JsFunctionDefinitionExpression CompileMethod(EntityDeclaration entity, BlockStatement body, IMethod method, MethodScriptSemantics impl) { bool isIEnumerable = method.ReturnType.IsKnownType(KnownTypeCode.IEnumerable) || method.ReturnType.IsKnownType(KnownTypeCode.IEnumerableOfT); bool isIEnumerator = method.ReturnType.IsKnownType(KnownTypeCode.IEnumerator) || method.ReturnType.IsKnownType(KnownTypeCode.IEnumeratorOfT); StateMachineType smt = StateMachineType.NormalMethod; IType iteratorBlockYieldTypeOrAsyncTaskGenericArgument = null; if ((isIEnumerable || isIEnumerator) && IsIteratorBlockVisitor.Analyze(body)) { smt = isIEnumerable ? StateMachineType.IteratorBlockReturningIEnumerable : StateMachineType.IteratorBlockReturningIEnumerator; iteratorBlockYieldTypeOrAsyncTaskGenericArgument = method.ReturnType is ParameterizedType ? ((ParameterizedType)method.ReturnType).TypeArguments[0] : _compilation.FindType(KnownTypeCode.Object); } else if (entity.HasModifier(Modifiers.Async)) { smt = (method.ReturnType.IsKnownType(KnownTypeCode.Void) ? StateMachineType.AsyncVoid : StateMachineType.AsyncTask); iteratorBlockYieldTypeOrAsyncTaskGenericArgument = method.ReturnType is ParameterizedType ? ((ParameterizedType)method.ReturnType).TypeArguments[0] : null; } CreateCompilationContext(entity, method, method.DeclaringTypeDefinition, (impl.Type == MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument ? _namer.ThisAlias : null)); return(_statementCompiler.CompileMethod(method.Parameters, variables, body, impl.Type == MethodScriptSemantics.ImplType.StaticMethodWithThisAsFirstArgument, impl.ExpandParams, smt, iteratorBlockYieldTypeOrAsyncTaskGenericArgument)); }
public static void EmitMethodParameters(AbstractEmitterBlock block, IEnumerable <ParameterDeclaration> declarations, AstNode context) { bool needComma = false; EntityDeclaration entityDeclaration = context as EntityDeclaration; if (entityDeclaration != null) { if (!entityDeclaration.HasModifier(Modifiers.Static)) { block.WriteThis(); if (declarations.Any()) { block.WriteComma(); } } } foreach (ParameterDeclaration p in declarations) { string name = p.Name; name = name.Replace(Bridge.Translator.Emitter.FIX_ARGUMENT_NAME, ""); if (block.Emitter.LocalsNamesMap != null && block.Emitter.LocalsNamesMap.ContainsKey(name)) { name = block.Emitter.LocalsNamesMap[name]; } if (needComma) { block.WriteComma(); } needComma = true; block.Write(name); } }
public static string GetStockIcon(this EntityDeclaration element) { Accessibility acc = Accessibility.None; // type accessibility acc = Accessibility.Internal; if (element.HasModifier(Modifiers.Public)) { acc = Accessibility.Public; } else if (element.HasModifier(Modifiers.Protected)) { acc = Accessibility.Protected; } else if (element.HasModifier(Modifiers.Private)) { acc = Accessibility.Private; } if (element is TypeDeclaration) { var type = element as TypeDeclaration; switch (type.ClassType) { case ClassType.Class: return(typeIconTable [0, ModifierToOffset(acc)]); case ClassType.Struct: return(typeIconTable [3, ModifierToOffset(acc)]); case ClassType.Interface: return(typeIconTable [2, ModifierToOffset(acc)]); case ClassType.Enum: return(typeIconTable [1, ModifierToOffset(acc)]); default: throw new ArgumentOutOfRangeException(); } } if (element is DelegateDeclaration) { return(typeIconTable [4, ModifierToOffset(acc)]); } // member accessibility acc = Accessibility.Private; if (element.HasModifier(Modifiers.Public)) { acc = Accessibility.Public; } else if (element.HasModifier(Modifiers.Protected)) { acc = Accessibility.Protected; } else if (element.HasModifier(Modifiers.Internal)) { acc = Accessibility.Internal; } if (element is MethodDeclaration) { var method = element as MethodDeclaration; if (method.IsExtensionMethod) { return(extensionMethodIconTable [ModifierToOffset(acc)]); } return(methodIconTable [ModifierToOffset(acc)]); } if (element is OperatorDeclaration || element is ConstructorDeclaration || element is DestructorDeclaration || element is Accessor) { return(methodIconTable [ModifierToOffset(acc)]); } if (element is PropertyDeclaration) { return(propertyIconTable [ModifierToOffset(acc)]); } if (element is EventDeclaration || element is CustomEventDeclaration) { return(eventIconTable [ModifierToOffset(acc)]); } return(fieldIconTable [ModifierToOffset(acc)]); }