void ConvertAttributes(AST.TypeMember node, AbstractEntity to) { if (node.Attributes.Count == 0) { to.Attributes = DefaultAttribute.EmptyAttributeList; } else { ClassFinder context; if (to is IClass) { context = new ClassFinder((IClass)to, node.LexicalInfo.Line, node.LexicalInfo.Column); } else { context = new ClassFinder(to.DeclaringType, node.LexicalInfo.Line, node.LexicalInfo.Column); } foreach (AST.Attribute a in node.Attributes) { to.Attributes.Add(new DefaultAttribute(new AttributeReturnType(context, a.Name)) { CompilationUnit = _cu, Region = GetRegion(a) }); } } to.Documentation = node.Documentation; }
void CheckExplicitTypeForVisibleMember(TypeMember node) { if (node.IsSynthetic || !node.IsVisible) return; switch (node.NodeType) //TODO: introduce INodeWithType? { case NodeType.Constructor: CheckExplicitParametersType(node); return; case NodeType.Method: Method method = (Method)node; if (null != method.ParentNode && method.ParentNode.NodeType == NodeType.Property) return; //ignore accessors CheckExplicitParametersType(node); if (null != method.ReturnType) return; if (method.Entity != null && ((IMethod)method.Entity).ReturnType == TypeSystemServices.VoidType) return; break; case NodeType.Property: if (null != ((Property)node).Type) return; break; case NodeType.Event: if (null != ((Event)node).Type) return; break; default: return; //fields, nested types etc... } Warnings.Add(CompilerWarningFactory.VisibleMemberDoesNotDeclareTypeExplicitely(node)); }
private void CheckMember(List<TypeMember> list, TypeMember member) { switch (member.NodeType) { case NodeType.StatementTypeMember: break; case NodeType.Constructor: case NodeType.Method: { CheckOverloadableMember(list, member); CheckLikelyTypoInTypeMemberName(member); break; } case NodeType.Property: { CheckOverloadableMember(list, member); break; } default: { CheckNonOverloadableMember(list, member); break; } } }
public void SetPublicByDefault(TypeMember node) { if (!node.get_IsVisibilitySet()) { node.set_Modifiers(node.get_Modifiers() | 8); } }
public static bool IsAttributeDefined(TypeMember member, IType attributeType) { foreach (var attr in member.Attributes) if (IsOfType(attr, attributeType)) return true; return false; }
public static TypeMember Lift(Statement stmt) { var typeMemberStatement = stmt as TypeMemberStatement; if (null != typeMemberStatement) { return(TypeMember.Lift(typeMemberStatement)); } var declaration = stmt as DeclarationStatement; if (null != declaration) { return(TypeMember.Lift(declaration)); } var expressionStatement = stmt as ExpressionStatement; if (null != expressionStatement) { return(TypeMember.Lift(expressionStatement)); } throw new NotImplementedException(stmt.ToCodeString()); }
public TypeMember Reify(TypeMember node) { if (ShouldReify()) { RunExpansionIterations(); } return node; }
protected void WarnIfPrivateMemberNeverUsed(TypeMember node) { if (node.IsPrivate && node.ContainsAnnotation("PrivateMemberNeverUsed")) { Warnings.Add( CompilerWarningFactory.PrivateMemberNeverUsed(node) ); } }
MemberAttributes ConvModifiers(TypeMember member) { bool strict = ConvertVisitor.IsStrictMode(pc); if (member is Field) return ConvModifiers(member.Modifiers, strict ? MemberAttributes.Private : MemberAttributes.Family); else return ConvModifiers(member.Modifiers, strict ? MemberAttributes.Private : MemberAttributes.Public); }
override public bool Replace(Node existing, Node newNode) { if (base.Replace(existing, newNode)) { return(true); } if (_attributes != null) { Attribute item = existing as Attribute; if (null != item) { Attribute newItem = (Attribute)newNode; if (_attributes.Replace(item, newItem)) { return(true); } } } if (_members != null) { TypeMember item = existing as TypeMember; if (null != item) { TypeMember newItem = (TypeMember)newNode; if (_members.Replace(item, newItem)) { return(true); } } } if (_baseTypes != null) { TypeReference item = existing as TypeReference; if (null != item) { TypeReference newItem = (TypeReference)newNode; if (_baseTypes.Replace(item, newItem)) { return(true); } } } if (_genericParameters != null) { GenericParameterDeclaration item = existing as GenericParameterDeclaration; if (null != item) { GenericParameterDeclaration newItem = (GenericParameterDeclaration)newNode; if (_genericParameters.Replace(item, newItem)) { return(true); } } } return(false); }
protected void WarnIfPrivateMemberNeverUsed(TypeMember node) { if (NodeType.Constructor == node.NodeType && node.IsStatic) return; if (!IsVisible(node) && node.ContainsAnnotation("PrivateMemberNeverUsed")) { Warnings.Add( CompilerWarningFactory.PrivateMemberNeverUsed(node) ); } }
void CheckExplicitParametersType(TypeMember node) { INodeWithParameters @params = node as INodeWithParameters; if (null == @params) return; foreach (ParameterDeclaration p in @params.Parameters) { if (null == p.Type) Warnings.Add(CompilerWarningFactory.VisibleMemberDoesNotDeclareTypeExplicitely(node, p.Name)); } }
public static TypeMember Lift(ExpressionStatement stmt) { var e = stmt.Expression; var closure = e as BlockExpression; if (closure != null) { return(TypeMember.Lift(closure)); } throw new NotImplementedException(stmt.ToCodeString()); }
private static void LiftBlockInto(TypeMemberCollection collection, Block block) { foreach (var stmt in block.Statements) { var childBlock = stmt as Block; if (childBlock != null) { LiftBlockInto(collection, childBlock); } else { collection.Add(TypeMember.Lift(stmt)); } } }
public static TypeMember Lift(DeclarationStatement stmt) { var closure = stmt.Initializer as BlockExpression; if (closure != null && closure.ContainsAnnotation(BlockExpression.ClosureNameAnnotation)) { return(TypeMember.Lift(closure)); } return(new Field(stmt.LexicalInfo) { Name = stmt.Declaration.Name, Type = stmt.Declaration.Type, Initializer = stmt.Initializer }); }
protected void CheckLikelyTypoInTypeMemberName(TypeMember member) { foreach (string name in GetLikelyTypoNames(member)) { if (name == member.Name) return; if (Math.Abs(name.Length - member.Name.Length) > 1) continue; //>1 distance, skip if (1 == StringUtilities.GetDistance(name, member.Name)) { Warnings.Add( CompilerWarningFactory.LikelyTypoInTypeMemberName(member, name)); break; } } }
override public object Clone() { TypeMember clone = (TypeMember)FormatterServices.GetUninitializedObject(typeof(TypeMember)); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._entity = _entity; if (_annotations != null) { clone._annotations = (Hashtable)_annotations.Clone(); } clone._modifiers = _modifiers; clone._name = _name; if (null != _attributes) { clone._attributes = _attributes.Clone() as AttributeCollection; clone._attributes.InitializeParent(clone); } return(clone); }
void CantBeMarkedAbstract(TypeMember member) { if (member.IsAbstract) { Error(CompilerErrorFactory.CantBeMarkedAbstract(member)); } }
public TypeMember Reify(TypeMember member) { Visit(member); return member; }
public SpliceTypeMember(LexicalInfo lexicalInfo, TypeMember typeMember, Expression nameExpression) : base(lexicalInfo) { this.TypeMember = typeMember; this.NameExpression = nameExpression; }
public SpliceTypeMember(TypeMember typeMember, Expression nameExpression) : this(typeMember.LexicalInfo, typeMember, nameExpression) { }
public TypeMember Reify(TypeMember node) { ApplyAttributesAndExpandMacros(); return node; }
bool IsNestedType(TypeMember type) { NodeType parent = type.ParentNode.NodeType; return (NodeType.ClassDefinition == parent) || (NodeType.InterfaceDefinition == parent); }
private void EnsureEntityFor(TypeMember member) { InternalTypeSystemProvider.EntityFor(member); }
void InvalidCombination(TypeMember member, TypeMemberModifiers mod1, TypeMemberModifiers mod2) { if (!member.IsModifierSet(mod1) || !member.IsModifierSet(mod2)) return; Error( CompilerErrorFactory.InvalidCombinationOfModifiers( member, EntityFor(member), string.Format("{0}, {1}", mod1.ToString().ToLower(), mod2.ToString().ToLower()))); }
void CheckModifierCombination(TypeMember member) { InvalidCombination(member, TypeMemberModifiers.Static, TypeMemberModifiers.Abstract); InvalidCombination(member, TypeMemberModifiers.Static, TypeMemberModifiers.Virtual); InvalidCombination(member, TypeMemberModifiers.Static, TypeMemberModifiers.Override); InvalidCombination(member, TypeMemberModifiers.Abstract, TypeMemberModifiers.Final); if (member.NodeType != NodeType.Field) { InvalidCombination(member, TypeMemberModifiers.Static, TypeMemberModifiers.Final); } }
void CantBeMarkedStatic(TypeMember member) { if (member.IsStatic) Error(CompilerErrorFactory.CantBeMarkedStatic(member)); }
void CantBeMarkedFinal(TypeMember member) { if (member.IsFinal) { Error(CompilerErrorFactory.CantBeMarkedFinal(member)); } }
void CantBeMarkedPartial(TypeMember member) { if (member.IsPartial) Error(CompilerErrorFactory.CantBeMarkedPartial(member)); }
public static TypeMember Lift(TypeMember member) { return(member); }
void CantBeMarkedTransient(TypeMember member) { if (member.HasTransientModifier) Error(CompilerErrorFactory.CantBeMarkedTransient(member)); }
public TypeMember Reify(TypeMember member) { Visit(member); var field = member as Field; if (field != null) FlushFieldInitializers((ClassDefinition) field.DeclaringType); return member; }
private IEntity EntityFor(TypeMember member) { return My<InternalTypeSystemProvider>.Instance.EntityFor(member); }
private void EnsureMemberWasVisited(TypeMember node) { if (WasVisited(node)) return; _context.TraceVerbose("Info {0} needs resolving.", node.Entity.Name); VisitMemberPreservingContext(node); }
void MakeStaticIfNeeded(TypeMember node) { var declaringType = node.DeclaringType; if (declaringType != null && declaringType.IsStatic) { if(node.IsStatic) Warnings.Add(CompilerWarningFactory.StaticClassMemberRedundantlyMarkedStatic(node, declaringType.Name, node.Name)); node.Modifiers |= TypeMemberModifiers.Static; } }
public TypeMember Visit(TypeMember node) { return((TypeMember)VisitNode(node)); }
protected virtual void VisitMemberPreservingContext(TypeMember node) { INamespace saved = NameResolutionService.CurrentNamespace; try { NameResolutionService.EnterNamespace((INamespace)node.DeclaringType.Entity); Visit(node); } finally { NameResolutionService.EnterNamespace(saved); } }
private ModifierEnum GetModifier(AST.TypeMember m) { ModifierEnum r = ModifierEnum.None; if (m.IsPublic) { r |= ModifierEnum.Public; } if (m.IsProtected) { r |= ModifierEnum.Protected; } if (m.IsPrivate) { r |= ModifierEnum.Private; } if (m.IsInternal) { r |= ModifierEnum.Internal; } if (!m.IsVisibilitySet) { if (IsStrictMode(_cu.ProjectContent)) { r |= ModifierEnum.Private; } else if (m is AST.Field) { r |= ModifierEnum.Protected; } else { r |= ModifierEnum.Public; } } if (m.IsStatic) { r |= ModifierEnum.Static; } if (m is AST.Field) { if (m.IsFinal) { r |= ModifierEnum.Readonly; } } else { if (m.IsFinal) { r |= ModifierEnum.Sealed; } } if (m.IsAbstract) { r |= ModifierEnum.Abstract; } if (m.IsOverride) { r |= ModifierEnum.Override; } if (m.IsSynthetic) { r |= ModifierEnum.Synthetic; } if (m.IsPartial) { r |= ModifierEnum.Partial; } if (m.LexicalInfo.IsValid && m.DeclaringType != null && m.LexicalInfo.Line < m.DeclaringType.LexicalInfo.Line) { // member added through attribute r |= ModifierEnum.Synthetic; } return(r); }
void PushMember(TypeMember member) { _memberStack.Push(member); }
B.ExplicitMemberInfo ConvertInterfaceImplementations(List <InterfaceImplementation> implementations, AttributedNode node, B.TypeMember targetMember) { if (implementations.Count == 0) { return(null); } if (implementations.Count > 1) { AddError(node, "Multiple explicit interface implementations are not supported"); } if (implementations[0].MemberName != targetMember.Name) { AddError(node, "Explicit interface implementation: Implementing member with different name is not supported"); } if (targetMember.Modifiers == B.TypeMemberModifiers.Private) { targetMember.Modifiers = B.TypeMemberModifiers.None; } else { AddError(node, "Explicit interface implementation: Only private methods can explicitly implement interfaces"); } B.TypeReference tr = ConvertTypeReference(implementations[0].InterfaceType); if (tr is B.SimpleTypeReference) { B.ExplicitMemberInfo explicitInfo = new B.ExplicitMemberInfo(GetLexicalInfo(node)); explicitInfo.InterfaceType = (B.SimpleTypeReference)tr; return(explicitInfo); } else { AddError(node, "Explicit interface implementation: invalid base type, expecting SimpleTypeReference"); return(null); } }
public int GetFirstParameterIndex(TypeMember member) { return member.IsStatic ? 0 : 1; }
override public bool Replace(Node existing, Node newNode) { if (base.Replace(existing, newNode)) { return(true); } if (_attributes != null) { Attribute item = existing as Attribute; if (null != item) { Attribute newItem = (Attribute)newNode; if (_attributes.Replace(item, newItem)) { return(true); } } } if (_members != null) { TypeMember item = existing as TypeMember; if (null != item) { TypeMember newItem = (TypeMember)newNode; if (_members.Replace(item, newItem)) { return(true); } } } if (_baseTypes != null) { TypeReference item = existing as TypeReference; if (null != item) { TypeReference newItem = (TypeReference)newNode; if (_baseTypes.Replace(item, newItem)) { return(true); } } } if (_genericParameters != null) { GenericParameterDeclaration item = existing as GenericParameterDeclaration; if (null != item) { GenericParameterDeclaration newItem = (GenericParameterDeclaration)newNode; if (_genericParameters.Replace(item, newItem)) { return(true); } } } if (_namespace == existing) { this.Namespace = (NamespaceDeclaration)newNode; return(true); } if (_imports != null) { Import item = existing as Import; if (null != item) { Import newItem = (Import)newNode; if (_imports.Replace(item, newItem)) { return(true); } } } if (_globals == existing) { this.Globals = (Block)newNode; return(true); } if (_assemblyAttributes != null) { Attribute item = existing as Attribute; if (null != item) { Attribute newItem = (Attribute)newNode; if (_assemblyAttributes.Replace(item, newItem)) { return(true); } } } return(false); }