/// <summary>
/// Makes the given node [EditorBrowsable(Never)].
/// </summary>
public static void MakeNonBrowsable(AttributedNode node)
{
AttributeSection section = new AttributeSection();
ICSharpCode.NRefactory.Parser.AST.Attribute attribute =
new ICSharpCode.NRefactory.Parser.AST.Attribute("System.ComponentModel.EditorBrowsable",
new List<Expression>(), null);
attribute.PositionalArguments.Add(new FieldReferenceExpression(new TypeReferenceExpression(
"System.ComponentModel.EditorBrowsableState"), "Never"));
section.Attributes.Add(attribute);
node.Attributes.Add(section);
}
ImageSource GetMemberOverlayedImage(AttributedNode attrNode, MemberIcon icon)
{
switch (attrNode.Modifiers & Modifiers.VisibilityMask)
{
case Modifiers.Protected:
return(Images.GetIcon(icon, AccessOverlayIcon.Protected, (attrNode.Modifiers & Modifiers.Static) == Modifiers.Static));
case Modifiers.Private:
return(Images.GetIcon(icon, AccessOverlayIcon.Private, (attrNode.Modifiers & Modifiers.Static) == Modifiers.Static));
case Modifiers.Internal:
return(Images.GetIcon(icon, AccessOverlayIcon.Internal, (attrNode.Modifiers & Modifiers.Static) == Modifiers.Static));
}
return(Images.GetIcon(icon, AccessOverlayIcon.Public, (attrNode.Modifiers & Modifiers.Static) == Modifiers.Static));
}
ImageSource GetTypeOverlayedImage(AttributedNode attrNode, TypeIcon icon)
{
switch (attrNode.Modifiers & Modifiers.VisibilityMask)
{
case Modifiers.Protected:
return(Images.GetIcon(icon, AccessOverlayIcon.Protected));
case Modifiers.Private:
return(Images.GetIcon(icon, AccessOverlayIcon.Private));
case Modifiers.Internal:
return(Images.GetIcon(icon, AccessOverlayIcon.Internal));
}
return(Images.GetIcon(icon, AccessOverlayIcon.Public));
}
/// <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);
}
}
void HandleTypeDeclaration(AttributedNode typeDeclaration)
{
if (typeDeclaration.EndLocation.Y > includeCommentsAfterLine)
{
includeCommentsAfterLine = typeDeclaration.EndLocation.Y;
}
if (firstType)
{
firstType = false;
ReplaceCurrentNode(new UsingDeclaration(DummyIdentifier));
}
else
{
RemoveCurrentNode();
}
}
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);
}
/// <summary>
/// Adds argfull and argless stubs for all PHP visible members.
/// </summary>
private void DynamizeMembers(TypeDeclaration type, TypeDeclaration outType)
{
List <Statement> populate_statements = new List <Statement>();
foreach (INode member in type.Children)
{
AttributedNode node = member as AttributedNode;
if (node != null && Utility.IsDecoratedByAttribute(node, "PHP.Core.PhpVisibleAttribute"))
{
MethodDeclaration method_decl;
PropertyDeclaration prop_decl;
if ((method_decl = member as MethodDeclaration) != null)
{
populate_statements.Add(DynamizeMethod(method_decl, outType));
}
else if ((prop_decl = member as PropertyDeclaration) != null)
{
populate_statements.Add(DynamizeProperty(prop_decl, outType));
}
else
{
throw new InvalidOperationException("PhpVisible applied to invalid member");
}
}
}
// add the __PopulateTypeDesc method
MethodDeclaration populator = new MethodDeclaration(
"__PopulateTypeDesc",
Modifier.Private | Modifier.Static,
new TypeReference("void", "System.Void"), new List <ParameterDeclarationExpression>(), null);
populator.Parameters.Add(new ParameterDeclarationExpression(new TypeReference("PhpTypeDesc"), "desc"));
populator.Body = new BlockStatement();
foreach (Statement stmt in populate_statements)
{
if (stmt != null)
{
populator.Body.AddChild(stmt);
}
}
outType.AddChild(populator);
}
public static T ParseTypeMember <T>(string expr, bool expectErrors = false) where T : AttributedNode
{
CSharpParser parser = new CSharpParser();
var members = parser.ParseTypeMembers(new StringReader(expr));
if (parser.HasErrors)
{
parser.ErrorPrinter.Errors.ForEach(err => Console.WriteLine(err.Message));
}
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
AttributedNode m = members.Single();
Type type = typeof(T);
Assert.IsTrue(type.IsAssignableFrom(m.GetType()), String.Format("Parsed member was {0} instead of {1} ({2})", m.GetType(), type, m));
return((T)m);
}
public virtual AttributedNode GetOverridingMethod(IMember baseMember, ClassFinder targetContext)
{
AbstractMember newMember = (AbstractMember)baseMember.Clone();
newMember.Modifiers &= ~(ModifierEnum.Virtual | ModifierEnum.Abstract);
newMember.Modifiers |= ModifierEnum.Override;
// set modifiers be before calling convert so that a body is generated
AttributedNode node = ConvertMember(newMember, targetContext);
node.Attributes.Clear(); // don't copy over attributes
if (!baseMember.IsAbstract)
{
// replace the method/property body with a call to the base method/property
MethodDeclaration method = node as MethodDeclaration;
if (method != null)
{
method.Body.Children.Clear();
if (method.TypeReference.Type == "System.Void")
{
method.Body.AddChild(new ExpressionStatement(CreateForwardingMethodCall(method)));
}
else
{
method.Body.AddChild(new ReturnStatement(CreateForwardingMethodCall(method)));
}
}
PropertyDeclaration property = node as PropertyDeclaration;
if (property != null)
{
Expression field = new BaseReferenceExpression().Member(property.Name);
if (!property.GetRegion.Block.IsNull)
{
property.GetRegion.Block.Children.Clear();
property.GetRegion.Block.Return(field);
}
if (!property.SetRegion.Block.IsNull)
{
property.SetRegion.Block.Children.Clear();
property.SetRegion.Block.Assign(field, new IdentifierExpression("value"));
}
}
}
return(node);
}
public static T ParseTypeMember <T>(string expr, bool expectErrors = false) where T : AttributedNode
{
if (expectErrors)
{
Assert.Ignore("errors not yet implemented");
}
CSharpParser parser = new CSharpParser();
var members = parser.ParseTypeMembers(new StringReader(expr));
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
AttributedNode m = members.Single();
Type type = typeof(T);
Assert.IsTrue(type.IsAssignableFrom(m.GetType()), String.Format("Parsed member was {0} instead of {1} ({2})", m.GetType(), type, m));
return((T)m);
}
public virtual AttributedNode GetOverridingMethod(IMember baseMember, ClassFinder targetContext)
{
AttributedNode node = ConvertMember(baseMember, targetContext);
node.Modifier &= ~(Modifiers.Virtual | Modifiers.Abstract);
node.Modifier |= Modifiers.Override;
MethodDeclaration method = node as MethodDeclaration;
if (method != null)
{
method.Body.Children.Clear();
if (method.TypeReference.SystemType == "System.Void")
{
method.Body.AddChild(new ExpressionStatement(CreateForwardingMethodCall(method)));
}
else
{
method.Body.AddChild(new ReturnStatement(CreateForwardingMethodCall(method)));
}
}
PropertyDeclaration property = node as PropertyDeclaration;
if (property != null)
{
Expression field = new FieldReferenceExpression(new BaseReferenceExpression(),
property.Name);
if (!property.GetRegion.Block.IsNull)
{
property.GetRegion.Block.Children.Clear();
property.GetRegion.Block.AddChild(new ReturnStatement(field));
}
if (!property.SetRegion.Block.IsNull)
{
property.SetRegion.Block.Children.Clear();
Expression expr = new AssignmentExpression(field,
AssignmentOperatorType.Assign,
new IdentifierExpression("value"));
property.SetRegion.Block.AddChild(new ExpressionStatement(expr));
}
}
return(node);
}
private static bool HasGenerateAttribute(INode node)
{
if (node is AttributedNode)
{
AttributedNode field = node as AttributedNode;
foreach (AttributeSection section in field.Attributes)
{
foreach (ICSharpCode.NRefactory.Ast.Attribute attribute in section.Attributes)
{
if (attribute.Name == "Generate")
{
return(true);
}
}
}
}
return(false);
}
public override void GenerateCode(List <AbstractNode> nodes, IList items)
{
foreach (IProperty property in currentClass.DefaultReturnType.GetProperties())
{
if (property.IsAbstract)
{
AttributedNode node = CodeGenerator.ConvertMember(property, classFinderContext);
node.Modifier &= ~(Modifiers.Abstract | Modifiers.Virtual);
node.Modifier |= Modifiers.Override;
nodes.Add(node);
}
}
foreach (IMethod method in currentClass.DefaultReturnType.GetMethods())
{
if (method.IsAbstract)
{
AttributedNode node = CodeGenerator.ConvertMember(method, classFinderContext);
node.Modifier &= ~(Modifiers.Abstract | Modifiers.Virtual);
node.Modifier |= Modifiers.Override;
nodes.Add(node);
}
}
}
void Run(string input, string expectedOutput)
{
ICompilationUnit cu = helper.Parse("a.cs", input + "\nclass DerivedClass {\n \n}");
Assert.AreEqual(2, cu.Classes.Count);
Assert.AreEqual(1, cu.Classes[0].Methods.Count + cu.Classes[0].Properties.Count);
IMember virtualMember;
if (cu.Classes[0].Properties.Count > 0)
{
virtualMember = cu.Classes[0].Properties[0];
}
else
{
virtualMember = cu.Classes[0].Methods[0];
}
CSharpCodeGenerator ccg = new CSharpCodeGenerator();
AttributedNode result = ccg.GetOverridingMethod(virtualMember, new ClassFinder(cu.Classes[1], 3, 1));
Assert.IsNotNull(result);
string output = ccg.GenerateCode(result, "");
Assert.AreEqual(expectedOutput, NormalizeWhitespace(output));
}
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);
}
public virtual string assign(AttributedNode attr, FilterEnv env)
{
return "";
}
public bool ContainsModifier(AttributedNode node, Modifiers modifier)
{
return((node.Modifier & modifier) == modifier);
}
/// <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;
}
}
}
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);
}
}
/// <summary>
/// Adds the methods implementing the <paramref name="interf"/> to the list
/// <paramref name="nodes"/>.
/// </summary>
public virtual void ImplementInterface(IList <AbstractNode> nodes, IReturnType interf, bool explicitImpl, IClass targetClass)
{
ClassFinder context = new ClassFinder(targetClass, targetClass.Region.BeginLine + 1, 0);
Modifiers implicitImplModifier = ConvertModifier(ModifierEnum.Public, context);
Modifiers explicitImplModifier = ConvertModifier(context.Language.ExplicitInterfaceImplementationIsPrivateScope ? ModifierEnum.None : ModifierEnum.Public, context);
List <IEvent> targetClassEvents = targetClass.DefaultReturnType.GetEvents();
bool requireAlternativeImplementation;
foreach (IEvent e in interf.GetEvents())
{
if (!InterfaceMemberAlreadyImplemented(targetClassEvents, e, out requireAlternativeImplementation))
{
EventDeclaration ed = ConvertMember(e, context);
ed.Attributes.Clear();
if (explicitImpl || requireAlternativeImplementation)
{
ed.InterfaceImplementations.Add(CreateInterfaceImplementation(e, context));
if (context.Language.RequiresAddRemoveRegionInExplicitInterfaceImplementation)
{
ed.AddRegion = new EventAddRegion(null);
ed.AddRegion.Block = CreateNotImplementedBlock();
ed.RemoveRegion = new EventRemoveRegion(null);
ed.RemoveRegion.Block = CreateNotImplementedBlock();
}
targetClassEvents.Add(CloneAndAddExplicitImpl(e, targetClass));
ed.Modifier = explicitImplModifier;
}
else
{
targetClassEvents.Add(e);
ed.Modifier = implicitImplModifier;
}
nodes.Add(ed);
}
}
List <IProperty> targetClassProperties = targetClass.DefaultReturnType.GetProperties();
foreach (IProperty p in interf.GetProperties())
{
if (!InterfaceMemberAlreadyImplemented(targetClassProperties, p, out requireAlternativeImplementation))
{
AttributedNode pd = ConvertMember(p, context);
pd.Attributes.Clear();
if (explicitImpl || requireAlternativeImplementation)
{
InterfaceImplementation impl = CreateInterfaceImplementation(p, context);
if (pd is IndexerDeclaration)
{
((IndexerDeclaration)pd).InterfaceImplementations.Add(impl);
}
else
{
((PropertyDeclaration)pd).InterfaceImplementations.Add(impl);
}
targetClassProperties.Add(CloneAndAddExplicitImpl(p, targetClass));
pd.Modifier = explicitImplModifier;
}
else
{
targetClassProperties.Add(p);
pd.Modifier = implicitImplModifier;
}
nodes.Add(pd);
}
}
List <IMethod> targetClassMethods = targetClass.DefaultReturnType.GetMethods();
foreach (IMethod m in interf.GetMethods())
{
if (!InterfaceMemberAlreadyImplemented(targetClassMethods, m, out requireAlternativeImplementation))
{
MethodDeclaration md = ConvertMember(m, context) as MethodDeclaration;
md.Attributes.Clear();
if (md != null)
{
if (explicitImpl || requireAlternativeImplementation)
{
md.InterfaceImplementations.Add(CreateInterfaceImplementation(m, context));
targetClassMethods.Add(CloneAndAddExplicitImpl(m, targetClass));
md.Modifier = explicitImplModifier;
}
else
{
targetClassMethods.Add(m);
md.Modifier = implicitImplModifier;
}
nodes.Add(md);
}
}
}
}
public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
var instanceCtors = typeDeclaration.Members.OfType <ConstructorDeclaration>().Where(c => (c.Modifiers & Modifiers.Static) == 0).ToArray();
var instanceCtorsNotChainingWithThis = instanceCtors.Where(ctor => !thisCallPattern.IsMatch(ctor.Body.Statements.FirstOrDefault())).ToArray();
if (instanceCtorsNotChainingWithThis.Length > 0 && typeDeclaration.ClassType == NRefactory.TypeSystem.ClassType.Class)
{
// Recognize field initializers:
// Convert first statement in all ctors (if all ctors have the same statement) into a field initializer.
bool allSame;
do
{
Match m = fieldInitializerPattern.Match(instanceCtorsNotChainingWithThis[0].Body.FirstOrDefault());
if (!m.Success)
{
break;
}
FieldDefinition fieldDef = m.Get <AstNode>("fieldAccess").Single().Annotation <FieldReference>().ResolveWithinSameModule();
if (fieldDef == null)
{
break;
}
AttributedNode fieldOrEventDecl = typeDeclaration.Members.FirstOrDefault(f => f.Annotation <FieldDefinition>() == fieldDef);
if (fieldOrEventDecl == null)
{
break;
}
allSame = true;
for (int i = 1; i < instanceCtorsNotChainingWithThis.Length; i++)
{
if (!instanceCtors[0].Body.First().IsMatch(instanceCtorsNotChainingWithThis[i].Body.FirstOrDefault()))
{
allSame = false;
}
}
if (allSame)
{
foreach (var ctor in instanceCtorsNotChainingWithThis)
{
ctor.Body.First().Remove();
}
fieldOrEventDecl.GetChildrenByRole(AstNode.Roles.Variable).Single().Initializer = m.Get <Expression>("initializer").Single().Detach();
}
} while (allSame);
}
// Now convert base constructor calls to initializers:
base.VisitTypeDeclaration(typeDeclaration, data);
// Remove single empty constructor:
if (instanceCtors.Length == 1)
{
ConstructorDeclaration emptyCtor = new ConstructorDeclaration();
emptyCtor.Modifiers = ((typeDeclaration.Modifiers & Modifiers.Abstract) == Modifiers.Abstract ? Modifiers.Protected : Modifiers.Public);
emptyCtor.Body = new BlockStatement();
if (emptyCtor.IsMatch(instanceCtors[0]))
{
instanceCtors[0].Remove();
}
}
// Convert static constructor into field initializers if the class is BeforeFieldInit
var staticCtor = typeDeclaration.Members.OfType <ConstructorDeclaration>().FirstOrDefault(c => (c.Modifiers & Modifiers.Static) == Modifiers.Static);
if (staticCtor != null)
{
TypeDefinition typeDef = typeDeclaration.Annotation <TypeDefinition>();
if (typeDef != null && typeDef.IsBeforeFieldInit)
{
while (true)
{
ExpressionStatement es = staticCtor.Body.Statements.FirstOrDefault() as ExpressionStatement;
if (es == null)
{
break;
}
AssignmentExpression assignment = es.Expression as AssignmentExpression;
if (assignment == null || assignment.Operator != AssignmentOperatorType.Assign)
{
break;
}
FieldDefinition fieldDef = assignment.Left.Annotation <FieldReference>().ResolveWithinSameModule();
if (fieldDef == null || !fieldDef.IsStatic)
{
break;
}
FieldDeclaration fieldDecl = typeDeclaration.Members.OfType <FieldDeclaration>().FirstOrDefault(f => f.Annotation <FieldDefinition>() == fieldDef);
if (fieldDecl == null)
{
break;
}
fieldDecl.Variables.Single().Initializer = assignment.Right.Detach();
es.Remove();
}
if (staticCtor.Body.Statements.Count == 0)
{
staticCtor.Remove();
}
}
}
return(null);
}
static bool IsMustOverride(AttributedNode node)
{
return(node.Modifiers.HasFlag(Modifiers.MustOverride));
}
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);
}
/// <summary>
/// Determines whether an attribute given by its full type name is contained in a attribute collections.
/// </summary>
public static bool IsDecoratedByAttribute(AttributedNode node, string attrTypeName)
{
return IsDecoratedByAttribute(node.Attributes, attrTypeName);
}
/// <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);
}
}
/**
* Pushes a single node onto this filter's input data queue.
*/
public void push(AttributedNode input)
{
in_nodes.Add(input);
}
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);
}
/// <summary>
/// Determines whether an attribute given by its full type name is contained in a attribute collections.
/// </summary>
public static bool IsDecoratedByAttribute(AttributedNode node, string attrTypeName)
{
return(IsDecoratedByAttribute(node.Attributes, attrTypeName));
}
public override string GenerateInterfaceForClass(string newInterfaceName, string existingCode, IList <IMember> membersToKeep, IClass sourceClass, bool preserveComments)
{
Modifiers modifiers = CodeGenerator.ConvertModifier(sourceClass.Modifiers, new ClassFinder(membersToKeep[0]));
// keep only visibility modifiers and 'unsafe' modifier
// -> remove abstract,sealed,static
modifiers &= Modifiers.Visibility | Modifiers.Unsafe;
TypeDeclaration interfaceDef = new TypeDeclaration(modifiers, new List <AttributeSection>());
interfaceDef.Name = newInterfaceName;
interfaceDef.Type = NR.Ast.ClassType.Interface;
interfaceDef.Templates = CodeGenerator.ConvertTemplates(sourceClass.TypeParameters, new ClassFinder(membersToKeep[0]));
foreach (IMember member in membersToKeep)
{
AttributedNode an = CodeGenerator.ConvertMember(member, new ClassFinder(member));
INode node = null;
if (an is MethodDeclaration)
{
MethodDeclaration m = an as MethodDeclaration;
m.Body = BlockStatement.Null;
m.Modifier = Modifiers.None;
node = m;
}
else
{
if (an is PropertyDeclaration)
{
PropertyDeclaration p = an as PropertyDeclaration;
p.GetRegion.Block = BlockStatement.Null;
p.SetRegion.Block = BlockStatement.Null;
p.Modifier = Modifiers.None;
node = p;
}
else
{
if (an is EventDeclaration)
{
EventDeclaration e = an as EventDeclaration;
e.Modifier = Modifiers.None;
node = e;
}
}
}
if (node == null)
{
throw new NotSupportedException();
}
interfaceDef.AddChild(node);
}
IOutputAstVisitor printer = this.GetOutputVisitor();
interfaceDef.AcceptVisitor(printer, null);
string codeForNewInterface = printer.Text;
// wrap the new code in the same comments/usings/namespace as the the original class file.
string newFileContent = CreateNewFileLikeExisting(existingCode, codeForNewInterface);
return(newFileContent);
}
private static void MakePublic(AttributedNode node)
{
node.Modifier = node.Modifier & ~Modifiers.Visibility | Modifiers.Public;
}
public static bool HasModifier(this AttributedNode node, Modifiers modifier)
{
return((node.Modifier & modifier) != 0);
}
public void AddModifierTo(AttributedNode node, Modifiers modifier)
{
node.Modifier |= modifier;
}
