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