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