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 void ReplaceModifiers(AttributedNode node, Modifiers oldModifier, Modifiers newModifier) { if (ContainsModifier(node, oldModifier)) { RemoveModifierFrom(node, oldModifier); AddModifierTo(node, newModifier); } }
public override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) { if ((propertyDeclaration.BodyStart < start) && (propertyDeclaration.BodyEnd > end)) { this.member = propertyDeclaration; } return base.VisitPropertyDeclaration(propertyDeclaration, data); }
B.TypeMemberModifiers ConvertModifier(AttributedNode node, B.TypeMemberModifiers defaultVisibility) { Modifiers m = node.Modifier; B.TypeMemberModifiers r = B.TypeMemberModifiers.None; if ((m & Modifiers.Private) != 0) r |= B.TypeMemberModifiers.Private; if ((m & Modifiers.Internal) != 0) r |= B.TypeMemberModifiers.Internal; if ((m & Modifiers.Public) != 0) r |= B.TypeMemberModifiers.Public; if ((m & Modifiers.Protected) != 0) r |= B.TypeMemberModifiers.Protected; if (r == B.TypeMemberModifiers.None) r = defaultVisibility; if ((m & Modifiers.Abstract) != 0) r |= B.TypeMemberModifiers.Abstract; if ((m & Modifiers.Virtual) != 0) r |= B.TypeMemberModifiers.Virtual; if ((m & Modifiers.Sealed) != 0) r |= B.TypeMemberModifiers.Final; if ((m & Modifiers.Static) != 0) { r |= B.TypeMemberModifiers.Static; } else if (currentType != null && currentType.IsStatic) { if (!(node is TypeDeclaration)) r |= B.TypeMemberModifiers.Static; } if ((m & Modifiers.Override) != 0) r |= B.TypeMemberModifiers.Override; if ((m & Modifiers.ReadOnly) != 0 && !(node is PropertyDeclaration)) { r |= B.TypeMemberModifiers.Final; } if ((m & Modifiers.Const) != 0) { r |= B.TypeMemberModifiers.Final | B.TypeMemberModifiers.Static; } if ((m & Modifiers.New) != 0) { AddError(node, "shadowing is not supported"); } if ((m & Modifiers.Partial) != 0) { r |= B.TypeMemberModifiers.Partial; } if ((m & Modifiers.Extern) != 0) { // not necessary in Boo } if ((m & Modifiers.Volatile) != 0) { AddError(node, "Volatile modifier is not supported"); } if ((m & Modifiers.Unsafe) != 0) { AddError(node, "Unsafe modifier is not supported"); } if ((m & Modifiers.Overloads) != 0) { // not necessary in Boo } if ((m & Modifiers.WithEvents) != 0) { // not necessary in Boo } return r; }
public override object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) { if ((operatorDeclaration.Body.StartLocation < start) && (operatorDeclaration.Body.EndLocation > end)) { this.member = operatorDeclaration; } return base.VisitOperatorDeclaration(operatorDeclaration, data); }
public override object VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data) { if ((destructorDeclaration.Body.StartLocation < start) && (destructorDeclaration.Body.EndLocation > end)) { this.member = destructorDeclaration; } return base.VisitDestructorDeclaration(destructorDeclaration, data); }
public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) { if ((constructorDeclaration.Body.StartLocation < start) && (constructorDeclaration.Body.EndLocation > end)) { this.member = constructorDeclaration; } return base.VisitConstructorDeclaration(constructorDeclaration, data); }
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { if ((methodDeclaration.Body.StartLocation < start) && (methodDeclaration.Body.EndLocation > end)) { this.member = methodDeclaration; } return base.VisitMethodDeclaration(methodDeclaration, data); }
void ConvertAttributes(AST.AttributedNode from, AbstractDecoration to) { if (from.Attributes.Count == 0) { to.Attributes = DefaultAttribute.EmptyAttributeList; } else { to.Attributes = VisitAttributes(from.Attributes); } }
/// <summary> /// Writes all specials up to the start position of the node. /// </summary> public void AcceptNodeStart(INode node) { if (node is AttributedNode) { currentAttributedNode = node as AttributedNode; if (currentAttributedNode.Attributes.Count == 0) { AcceptPoint(node.StartLocation); currentAttributedNode = null; } } else { AcceptPoint(node.StartLocation); } }
/// <summary> /// Writes all specials up to the end position of the node. /// </summary> public void AcceptNodeEnd(INode node) { visitor.ForceWriteInPreviousLine = true; AcceptPoint(node.EndLocation); visitor.ForceWriteInPreviousLine = false; if (currentAttributedNode != null) { if (node == currentAttributedNode.Attributes[currentAttributedNode.Attributes.Count - 1]) { AcceptPoint(currentAttributedNode.StartLocation); currentAttributedNode = null; } } }
protected static Statement CreateCaller(AttributedNode parent, MethodDeclaration method, VariableDeclaration returnVariable) { Statement caller; InvocationExpression expr = new InvocationExpression(new IdentifierExpression(method.Name), CreateArgumentExpressions(method.Parameters)); if (method.TypeReference.Type != "System.Void") { TypeReference parentType = GetParentReturnType(parent); if (method.TypeReference == parentType) caller = new ReturnStatement(expr); else { returnVariable.Initializer = expr; caller = new LocalVariableDeclaration(returnVariable); } } else { caller = new ExpressionStatement(expr); } return caller; }
static bool IsExternAllowed(Ast.AttributedNode type, Ast.AttributedNode member) { if (type is Ast.TypeDeclaration) { var decl = type as Ast.TypeDeclaration; if (decl.Type == Ast.ClassType.Interface || (decl.Type == Ast.ClassType.Struct && member is Ast.PropertyDeclaration)) { return(false); } } if (member.Modifier.HasFlag(Ast.Modifiers.Abstract)) { return(false); } return(true); }
static bool NeedsBody(Ast.AttributedNode type, Ast.AttributedNode member) { if (type is Ast.TypeDeclaration) { var decl = type as Ast.TypeDeclaration; if (decl.Type == Ast.ClassType.Interface) { return(false); } } if (member.Modifier.HasFlag(Ast.Modifiers.Abstract) || member.Modifier.HasFlag(Ast.Modifiers.Extern)) { return(false); } return(true); }
void ConvertAttributes(AST.AttributedNode from, AbstractEntity to) { if (from.Attributes.Count == 0) { to.Attributes = DefaultAttribute.EmptyAttributeList; } else { ICSharpCode.NRefactory.Location location = from.Attributes[0].StartLocation; ClassFinder context; if (to is IClass) { context = new ClassFinder((IClass)to, location.Line, location.Column); } else { context = new ClassFinder(to.DeclaringType, location.Line, location.Column); } to.Attributes = VisitAttributes(from.Attributes, context); } }
static void WriteClass(IClass c, IClass compound, IProject project, TextWriter writer, string excludeFilename) { if (FileUtility.IsEqualFileName(excludeFilename, c.CompilationUnit.FileName)) { return; } if (project != null) { FileProjectItem file = project.FindFile(c.CompilationUnit.FileName); if (file == null || file.BuildAction != "Compile") { return; } } Ast.AttributedNode type = CodeGenerator.ConvertClass(c, null); CleanType(type); if (compound != null) { type.Modifier = CodeGenerator.ConvertModifier(compound.Modifiers, null); } CSharpOutputVisitor output = new CSharpOutputVisitor(); type.AcceptVisitor(output, null); // TODO : add fine grained mappings of files/lines writer.WriteLine(CreateLineMarker(c.Region.BeginLine - 1, c.CompilationUnit.FileName)); if (!string.IsNullOrEmpty(c.Namespace)) { writer.WriteLine("namespace " + c.Namespace + "{"); writer.Write(output.Text); writer.WriteLine("}"); } else { writer.Write(output.Text); } }
public void AddModifierTo(AttributedNode node, Modifiers modifier) { node.Modifier |= modifier; }
private static void MakePublic(AttributedNode node) { node.Modifier = node.Modifier & ~Modifiers.Visibility | Modifiers.Public; }
/// <summary> /// Finds the attribute on the given node. /// </summary> /// <param name = "declaration">The declaration.</param> /// <param name = "attributeName">Name of the attribute.</param> /// <returns></returns> protected static Attribute FindAttribute(AttributedNode declaration, String attributeName) { foreach (AttributeSection attributeSection in declaration.Attributes) { foreach (Attribute attribute in attributeSection.Attributes) { if (String.Equals (attribute.Name, attributeName)) { return attribute; } } } return null; }
static void CleanType(Ast.AttributedNode type) { foreach (Ast.AttributeSection section in type.Attributes) { section.Attributes.RemoveAll(a => !allowedAttributes.Contains(a.Name)); } type.Attributes.RemoveAll(s => !s.Attributes.Any()); foreach (Ast.MethodDeclaration node in type.Children.OfType <Ast.MethodDeclaration>()) { if (node.Body != null) { if (IsExternAllowed(type, node)) { node.Modifier |= Ast.Modifiers.Extern; } if (!NeedsBody(type, node)) { node.Body = null; } } } foreach (Ast.ConstructorDeclaration node in type.Children.OfType <Ast.ConstructorDeclaration>()) { if (IsExternAllowed(type, node)) { node.Modifier |= Ast.Modifiers.Extern; } if (!NeedsBody(type, node)) { node.Body = null; } } foreach (Ast.DestructorDeclaration node in type.Children.OfType <Ast.DestructorDeclaration>()) { if (IsExternAllowed(type, node)) { node.Modifier |= Ast.Modifiers.Extern; } if (!NeedsBody(type, node)) { node.Body = null; } } foreach (Ast.PropertyDeclaration node in type.Children.OfType <Ast.PropertyDeclaration>()) { if (IsExternAllowed(type, node)) { node.Modifier |= Ast.Modifiers.Extern; } if (node.HasGetRegion && !NeedsBody(type, node)) { node.GetRegion.Block = null; } if (node.HasSetRegion && !NeedsBody(type, node)) { node.SetRegion.Block = null; } } foreach (Ast.AttributedNode node in type.Children.OfType <Ast.AttributedNode>()) { CleanType(node); } }
public bool ContainsModifier(AttributedNode node, Modifiers modifier) { return (node.Modifier & modifier) == modifier; }
static TypeReference GetParentReturnType(AttributedNode parent) { if (parent is MemberNode) return (parent as MemberNode).TypeReference; return null; }
public void RemoveModifierFrom(AttributedNode node, Modifiers modifier) { if (ContainsModifier(node, modifier)) node.Modifier -= modifier; }
private void ReplaceModifiers(AttributedNode member) { if (member.Parent.Parent is TypeDeclaration) AstUtil.ReplaceModifiers(member, Modifiers.Private, Modifiers.Internal); }
void HandleTypeDeclaration(AttributedNode typeDeclaration) { if (typeDeclaration.EndLocation.Y > includeCommentsAfterLine) includeCommentsAfterLine = typeDeclaration.EndLocation.Y; if (firstType) { firstType = false; ReplaceCurrentNode(new UsingDeclaration(DummyIdentifier)); } else { RemoveCurrentNode(); } }
B.TypeMemberModifiers ConvertModifier(AttributedNode node, B.TypeMemberModifiers defaultVisibility) { Modifiers m = node.Modifier; B.TypeMemberModifiers r = B.TypeMemberModifiers.None; if ((m & Modifiers.Private) != 0) r |= B.TypeMemberModifiers.Private; if ((m & Modifiers.Internal) != 0) r |= B.TypeMemberModifiers.Internal; if ((m & Modifiers.Public) != 0) r |= B.TypeMemberModifiers.Public; if ((m & Modifiers.Protected) != 0) r |= B.TypeMemberModifiers.Protected; if (r == B.TypeMemberModifiers.None) r = defaultVisibility; if ((m & Modifiers.Abstract) != 0) r |= B.TypeMemberModifiers.Abstract; if ((m & Modifiers.Virtual) != 0) r |= B.TypeMemberModifiers.Virtual; if ((m & Modifiers.Sealed) != 0) r |= B.TypeMemberModifiers.Final; if ((m & Modifiers.Static) != 0) { r |= B.TypeMemberModifiers.Static; } else if (currentType != null && currentType.IsStatic) { if (!(node is TypeDeclaration)) r |= B.TypeMemberModifiers.Static; } if ((m & Modifiers.Override) != 0) r |= B.TypeMemberModifiers.Override; if ((m & Modifiers.ReadOnly) != 0 && !(node is PropertyDeclaration)) { r |= B.TypeMemberModifiers.Final; } if ((m & Modifiers.Const) != 0) { r |= B.TypeMemberModifiers.Final | B.TypeMemberModifiers.Static; } if ((m & Modifiers.New) != 0) { AddError(node, "shadowing is not supported"); } if ((m & Modifiers.Partial) != 0) { r |= B.TypeMemberModifiers.Partial; } if ((m & Modifiers.Extern) != 0) { // not necessary in Boo } if ((m & Modifiers.Volatile) != 0) { AddError(node, "Volatile modifier is not supported"); } if ((m & Modifiers.Unsafe) != 0) { AddError(node, "Unsafe modifier is not supported"); } if ((m & Modifiers.Overloads) != 0) { // not necessary in Boo } if ((m & Modifiers.WithEvents) != 0) { // not necessary in Boo } if ((m & Modifiers.Default) != 0) { ParametrizedNode parametrizedNode = node as ParametrizedNode; string name = null; if (parametrizedNode != null) { name = parametrizedNode.Name; } else { AddError(node, "Default modifier is not supported on this member."); } if (name != null && currentType != null) { currentType.Attributes.Add(MakeAttribute("System.Reflection.DefaultMember", new B.StringLiteralExpression(name))); } } return r; }
protected static bool HasOccurrencesAfter(StringComparer nameComparer, AttributedNode member, Location location, string name, Location start, Location end) { FindReferenceVisitor frv = new FindReferenceVisitor(nameComparer, name, start, end); member.AcceptVisitor(frv, null); foreach (IdentifierExpression identifier in frv.Identifiers) { if (identifier.StartLocation > location) return true; } return false; }
ICSharpCode.NRefactory.Ast.Attribute GetPropertyAttribute (AttributedNode method, string name) { foreach (var i in method.Attributes) { foreach (var j in i.Attributes) { if (j.Name == name) return j; } } return null; }