private CodeRoot GetPrevGenOrNewGenRoot()
{
Class cl = new Class(controller, "Class1");
cl.IsPartial = true;
cl.GenericTypes.Add("T");
AttributeSection attrs = new AttributeSection(controller);
Attribute attr = new Attribute(controller);
attr.PositionalArguments.Add("true");
attr.Name = "Serializable";
attrs.AddAttribute(attr);
cl.AddAttributeSection(attrs);
// Create another class to match to the user one.
Class c3 = new Class(controller, "Class3");
Namespace ns = new Namespace(controller);
ns.Name = "ArchAngel.Tests";
ns.AddChild(cl);
ns.AddChild(c3);
CodeRoot root = new CodeRoot(controller);
root.AddChild(ns);
return(root);
}
protected CodeRoot CreateClassAndNamespace(IEnumerable <IBaseConstruct> children)
{
Class cl = new Class(controller, "Class1");
foreach (IBaseConstruct child in children)
{
cl.AddChild(child);
}
cl.Index = 10;
AttributeSection attrs = new AttributeSection(controller);
attrs.Index = 5;
Attribute attr = new Attribute(controller);
attr.Index = 6;
attr.PositionalArguments.Add("true");
attr.Name = "Serializable";
attrs.AddAttribute(attr);
cl.AddAttributeSection(attrs);
Namespace ns = new Namespace(controller);
ns.Index = 0;
ns.Name = "ArchAngel.Tests";
ns.AddChild(cl);
CodeRoot userRoot = new CodeRoot(controller);
userRoot.AddChild(ns);
return(userRoot);
}
public static T add_Attribute <T>(this T attributedNode, Attribute attribute) where T : AttributedNode
{
var attributeSection = new AttributeSection();
attributeSection.Attributes.Add(attribute);
return(attributedNode.add_Attribute(attributeSection));
}
private void SetAttributeValueOrAddAttributeIfNotDefault(
SyntaxTree syntaxTree,
string attributeName,
object value,
object defaultValue,
Expression valueExpression)
{
if (value == null)
{
return;
}
var attribute = syntaxTree.Children.OfType <AttributeSection>().SelectMany(x => x.Attributes)
.FirstOrDefault(x => x.Type is SimpleType && ((SimpleType)x.Type).Identifier == attributeName);
if (attribute != null)
{
attribute.Arguments.Clear();
attribute.Arguments.Add(valueExpression);
}
else if (!value.Equals(defaultValue))
{
attribute = new Attribute {
Type = new SimpleType(attributeName)
};
attribute.Arguments.Add(valueExpression);
var attributeSection = new AttributeSection(attribute)
{
AttributeTarget = "assembly"
};
syntaxTree.AddChild(attributeSection, new NRefactory.Role <AttributeSection>("Member"));
}
}
/// <summary>
/// Makes sure that the PHP-visible type is serializable.
/// </summary>
private void AddSerializibility(TypeDeclaration type, TypeDeclaration outType)
{
// make the type serializable
if (!Utility.IsDecoratedByAttribute(type, "System.SerializableAttribute"))
{
AttributeSection section = new AttributeSection();
section.Attributes.Add(new ICSharpCode.NRefactory.Parser.AST.Attribute("Serializable", null, null));
outType.Attributes.Add(section);
ConstructorDeclaration ctor = new ConstructorDeclaration(type.Name,
((type.Modifier & Modifier.Sealed) == Modifier.Sealed ? Modifier.Private : Modifier.Protected),
new List <ParameterDeclarationExpression>(), null);
ctor.Parameters.Add(
new ParameterDeclarationExpression(new TypeReference("System.Runtime.Serialization.SerializationInfo"), "info"));
ctor.Parameters.Add(
new ParameterDeclarationExpression(new TypeReference("System.Runtime.Serialization.StreamingContext"), "context"));
ctor.ConstructorInitializer = new ConstructorInitializer();
ctor.ConstructorInitializer.ConstructorInitializerType = ConstructorInitializerType.Base;
ctor.ConstructorInitializer.Arguments.Add(new IdentifierExpression("info"));
ctor.ConstructorInitializer.Arguments.Add(new IdentifierExpression("context"));
ctor.Body = new BlockStatement();
outType.AddChild(ctor);
}
}
IEnumerable <CodeAction> GetActions(Attribute attribute, AttributeSection attributeSection, FieldDeclaration fieldDeclaration)
{
string removeAttributeMessage = ctx.TranslateString("Remove attribute");
yield return(new CodeAction(removeAttributeMessage, script =>
{
if (attributeSection.Attributes.Count > 1)
{
var newSection = new AttributeSection();
newSection.AttributeTarget = attributeSection.AttributeTarget;
foreach (var attr in attributeSection.Attributes)
{
if (attr != attribute)
{
newSection.Attributes.Add((Attribute)attr.Clone());
}
}
script.Replace(attributeSection, newSection);
}
else
{
script.Remove(attributeSection);
}
}));
var makeStaticMessage = ctx.TranslateString("Make the field static");
yield return(new CodeAction(makeStaticMessage, script =>
{
var newDeclaration = (FieldDeclaration)fieldDeclaration.Clone();
newDeclaration.Modifiers |= Modifiers.Static;
script.Replace(fieldDeclaration, newDeclaration);
}));
}
/// <summary>
/// Makes sure that the PHP-visible type is serializable.
/// </summary>
private void AddSerializibility(TypeDeclaration type, TypeDeclaration outType)
{
// make the type serializable
if (!Utility.IsDecoratedByAttribute(type, "System.SerializableAttribute"))
{
AttributeSection section = new AttributeSection();
section.Attributes.Add(new ICSharpCode.NRefactory.Parser.AST.Attribute("Serializable", null, null));
outType.Attributes.Add(section);
ConstructorDeclaration ctor = new ConstructorDeclaration(type.Name,
((type.Modifier & Modifier.Sealed) == Modifier.Sealed ? Modifier.Private : Modifier.Protected),
new List<ParameterDeclarationExpression>(), null);
ctor.Parameters.Add(
new ParameterDeclarationExpression(new TypeReference("System.Runtime.Serialization.SerializationInfo"), "info"));
ctor.Parameters.Add(
new ParameterDeclarationExpression(new TypeReference("System.Runtime.Serialization.StreamingContext"), "context"));
ctor.ConstructorInitializer = new ConstructorInitializer();
ctor.ConstructorInitializer.ConstructorInitializerType = ConstructorInitializerType.Base;
ctor.ConstructorInitializer.Arguments.Add(new IdentifierExpression("info"));
ctor.ConstructorInitializer.Arguments.Add(new IdentifierExpression("context"));
ctor.Body = new BlockStatement();
outType.AddChild(ctor);
}
}
public override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data)
{
if (usings != null && !usings.ContainsKey("System.Runtime.InteropServices"))
{
UsingDeclaration @using = new UsingDeclaration("System.Runtime.InteropServices");
addedUsings.Add(@using);
base.VisitUsingDeclaration(@using, data);
}
MethodDeclaration method = new MethodDeclaration(declareDeclaration.Name, declareDeclaration.Modifier,
declareDeclaration.TypeReference, declareDeclaration.Parameters,
declareDeclaration.Attributes);
if ((method.Modifier & Modifiers.Visibility) == 0)
{
method.Modifier |= Modifiers.Public;
}
method.Modifier |= Modifiers.Extern | Modifiers.Static;
if (method.TypeReference.IsNull)
{
method.TypeReference = new TypeReference("System.Void");
}
Attribute att = new Attribute("DllImport", null, null);
att.PositionalArguments.Add(CreateStringLiteral(declareDeclaration.Library));
if (declareDeclaration.Alias.Length > 0)
{
att.NamedArguments.Add(new NamedArgumentExpression("EntryPoint", CreateStringLiteral(declareDeclaration.Alias)));
}
switch (declareDeclaration.Charset)
{
case CharsetModifier.Auto:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new FieldReferenceExpression(new IdentifierExpression("CharSet"),
"Auto")));
break;
case CharsetModifier.Unicode:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new FieldReferenceExpression(new IdentifierExpression("CharSet"),
"Unicode")));
break;
default:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new FieldReferenceExpression(new IdentifierExpression("CharSet"),
"Ansi")));
break;
}
att.NamedArguments.Add(new NamedArgumentExpression("SetLastError", new PrimitiveExpression(true, true.ToString())));
att.NamedArguments.Add(new NamedArgumentExpression("ExactSpelling", new PrimitiveExpression(true, true.ToString())));
AttributeSection sec = new AttributeSection(null, null);
sec.Attributes.Add(att);
method.Attributes.Add(sec);
ReplaceCurrentNode(method);
return(base.VisitMethodDeclaration(method, data));
}
public void Class()
{
Class cl = new Class(controller, "Class1");
cl.IsPartial = true;
cl.GenericTypes.Add("T");
AttributeSection attrs = new AttributeSection(controller);
Attribute attr = new Attribute(controller);
attr.PositionalArguments.Add("true");
attr.Name = "Serializable";
attrs.AddAttribute(attr);
cl.AddAttributeSection(attrs);
Namespace ns = new Namespace(controller);
ns.Name = "ArchAngel.Tests";
ns.AddChild(cl);
CodeRoot root = new CodeRoot(controller);
root.AddChild(ns);
CodeRootMap map = new CodeRootMap();
map.AddCodeRoot(root, Version.User);
map.AddCodeRoot(root, Version.NewGen);
map.AddCodeRoot(root, Version.PrevGen);
string result = map.GetMergedCodeRoot().ToString();
Assert.That(result, Is.EqualTo(root.ToString()));
Assertions.StringContains(result, "class Class1");
Assertions.StringContains(result, "[Serializable(true)]");
Assertions.StringContains(result, "namespace ArchAngel.Tests");
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
int startSearch = FieldToAddTo.TextRange.StartOffset;
string text = sb.ToString();
// Put the new Attribute just in front of the property declaration.
int insertionPoint = text.LastIndexOf("\n", startSearch) + 1;
AttributeSection section = new AttributeSection(AttributeToAdd.Controller);
section.AddAttribute(AttributeToAdd);
section.PreceedingBlankLines = -1;
var indentLevel = InsertionHelpers.GetIndentationInFrontOf(text, startSearch);
section.Controller.IndentLevel = indentLevel;
string newText = Helper.StandardizeLineBreaks(section.ToString(), "\n") + "\n";
// Calculate the Attribute's Text Range
// The start index is the insertion point + the number of tabs in front of the attribute, +1 for the \n
AttributeToAdd.TextRange.StartOffset = insertionPoint + indentLevel + 1;
AttributeToAdd.TextRange.EndOffset = AttributeToAdd.TextRange.StartOffset + (newText.Trim()).Length;
sb.Insert(insertionPoint, newText);
FieldToAddTo.AttributeSections.Add(section);
//return new ActionResult(insertionPoint, newText.Length, new[] { AttributeToAdd });
return new ActionResult(AttributeToAdd.TextRange.StartOffset, newText.Length, new[] { AttributeToAdd });
}
public override ActionResult ApplyActionTo(StringBuilder sb)
{
int startSearch = PropertyToAddTo.TextRange.StartOffset;
string text = sb.ToString();
// Put the new Attribute just in front of the property declaration.
int insertionPoint = text.LastIndexOf("\n", startSearch) + 1;
AttributeSection section = new AttributeSection(AttributeToAdd.Controller);
section.AddAttribute(AttributeToAdd);
section.PreceedingBlankLines = -1;
var indentLevel = InsertionHelpers.GetIndentationInFrontOf(text, startSearch);
section.Controller.IndentLevel = indentLevel;
string newText = Helper.StandardizeLineBreaks(section.ToString(), "\n") + "\n";
// Calculate the Attribute's Text Range
// The start index is the insertion point + the number of tabs in front of the attribute, +1 for the \n
AttributeToAdd.TextRange.StartOffset = insertionPoint + indentLevel + 1;
AttributeToAdd.TextRange.EndOffset = AttributeToAdd.TextRange.StartOffset + (newText.Trim()).Length;
sb.Insert(insertionPoint, newText);
PropertyToAddTo.AttributeSections.Add(section);
//return new ActionResult(insertionPoint, newText.Length, new[] { AttributeToAdd });
return(new ActionResult(AttributeToAdd.TextRange.StartOffset, newText.Length, new[] { AttributeToAdd }));
}
public static void AddAttribute(this AttributedNode typeDeclaration, string name, Expression[] positionalArguments, params NamedArgumentExpression[] namedArguments)
{
var section = new AttributeSection();
section.Attributes.Add(new ICSharpCode.NRefactory.Ast.Attribute(name, positionalArguments.ToList(), namedArguments.ToList()));
typeDeclaration.Attributes.Add(section);
}
public override void VisitAttributeSection(AttributeSection attributeSection)
{
base.VisitAttributeSection(attributeSection);
if (attributeSection.Attributes.Count == 0)
{
attributeSection.Remove();
}
}
public void AssemblyAttributeCSharp()
{
string program = @"[assembly: System.Attribute()]";
AttributeSection decl = ParseUtilCSharp.ParseGlobal <AttributeSection>(program);
Assert.AreEqual(new AstLocation(1, 1), decl.StartLocation);
Assert.AreEqual("assembly", decl.AttributeTarget);
}
public void AssemblyAttributeVBNet()
{
string program = @"<assembly: System.Attribute()>";
AttributeSection decl = ParseUtilVBNet.ParseGlobal <AttributeSection>(program);
Assert.AreEqual(new Location(1, 1), decl.StartLocation);
Assert.AreEqual("assembly", decl.AttributeTarget);
}
public void ModuleAttributeCSharp()
{
string program = @"[module: System.Attribute()]";
AttributeSection decl = ParseUtilCSharp.ParseGlobal <AttributeSection>(program);
Assert.AreEqual(new AstLocation(1, 1), decl.StartLocation);
Assert.AreEqual(AttributeTarget.Module, decl.AttributeTarget);
}
public override object VisitAttributeSection(AttributeSection attributeSection, object data)
{
foreach (Attribute attribute in attributeSection.Attributes)
{
attribute.Parent = attributeSection;
}
return(base.VisitAttributeSection(attributeSection, data));
}
public void AttributeSection()
{
AttributeSection inter = new AttributeSection(controller);
inter.Target = "";
Assert.That(inter.IsTheSame(inter.Clone(), ComparisonDepth.Outer), Is.True);
}
public override void VisitAttributeSection(AttributeSection attributeSection)
{
VisitChildrenToFormat(attributeSection, child => {
child.AcceptVisitor(this);
if (child.NextSibling != null && child.NextSibling.Role == Roles.RBracket) {
ForceSpacesAfter(child, false);
}
});
}
public void AddAttributeSection(AttributeSection sec)
{
sec.ParentObject = this;
_AttributeSections.Add(sec);
foreach (Attribute attr in sec.SingleAttributes)
{
_Attributes.Add(attr);
}
}
public void Matching_Successful()
{
controller.Reorder = true;
Class cl = new Class(controller, "Class1");
cl.IsPartial = true;
cl.GenericTypes.Add("T");
Class c2 = new Class(controller, "Class2"); // Extra class in user
AttributeSection attrs = new AttributeSection(controller);
Attribute attr = new Attribute(controller);
attr.PositionalArguments.Add("true");
attr.Name = "Serializable";
attrs.AddAttribute(attr);
cl.AddAttributeSection(attrs);
Namespace ns = new Namespace(controller);
ns.Name = "ArchAngel.Tests";
ns.AddChild(cl);
ns.AddChild(c2);
CodeRoot root = new CodeRoot(controller);
root.AddChild(ns);
CodeRootMap map = new CodeRootMap();
map.AddCodeRoot(root, Version.User);
root = GetPrevGenOrNewGenRoot();
map.AddCodeRoot(root, Version.PrevGen);
root = GetPrevGenOrNewGenRoot();
map.AddCodeRoot(root, Version.NewGen);
bool matchResult = map.MatchConstructs("ArchAngel.Tests|Class2", "ArchAngel.Tests|Class3", "ArchAngel.Tests|Class3");
Assert.That(matchResult, Is.True);
string result = map.GetMergedCodeRoot().ToString();
Assert.That(map.Diff(), Is.EqualTo(TypeOfDiff.UserChangeOnly));
Assertions.StringContains(result, "class Class1");
Assertions.StringContains(result, "[Serializable(true)]");
Assertions.StringContains(result, "namespace ArchAngel.Tests");
Assertions.StringContains(result, "Class2");
Assertions.StringContains(result, "Class3", 0);
int count = 0;
foreach (CodeRootMapNode node in map.AllNodes)
{
if (node.IsTheSameReference(c2))
{
count++;
}
}
Assert.That(count, Is.EqualTo(1));
}
public void ModuleAttribute()
{
string program = @"[module: System.Attribute()]";
AttributeSection decl = ParseUtilCSharp.ParseGlobal <AttributeSection>(program);
Assert.AreEqual(new TextLocation(1, 1), decl.StartLocation);
Assert.AreEqual("module", decl.AttributeTarget);
Assert.AreEqual(SyntaxTree.MemberRole, decl.Role);
}
public virtual object VisitAttributeSection(AttributeSection attributeSection, object data) {
Debug.Assert((attributeSection != null));
Debug.Assert((attributeSection.Attributes != null));
foreach (ICSharpCode.NRefactory.Ast.Attribute o in attributeSection.Attributes) {
Debug.Assert(o != null);
o.AcceptVisitor(this, data);
}
return null;
}
public void TypeAttribute()
{
string program = @"[type: System.Attribute()] class Test {}";
TypeDeclaration type = ParseUtilCSharp.ParseGlobal <TypeDeclaration>(program);
AttributeSection decl = type.Attributes.Single();
Assert.AreEqual(new TextLocation(1, 1), decl.StartLocation);
Assert.AreEqual("type", decl.AttributeTarget);
}
PropertyDeclaration TransformAutomaticProperties(PropertyDeclaration property)
{
PropertyDefinition cecilProperty = context.TypeSystem.GetCecil(property.GetSymbol() as IProperty) as PropertyDefinition;
if (cecilProperty == null || cecilProperty.GetMethod == null)
{
return(null);
}
if (!cecilProperty.GetMethod.IsCompilerGenerated() && (cecilProperty.SetMethod?.IsCompilerGenerated() == false))
{
return(null);
}
IField fieldInfo = null;
Match m = automaticPropertyPattern.Match(property);
if (m.Success)
{
fieldInfo = m.Get <AstNode>("fieldReference").Single().GetSymbol() as IField;
}
else
{
Match m2 = automaticReadonlyPropertyPattern.Match(property);
if (m2.Success)
{
fieldInfo = m2.Get <AstNode>("fieldReference").Single().GetSymbol() as IField;
}
}
if (fieldInfo == null)
{
return(null);
}
FieldDefinition field = context.TypeSystem.GetCecil(fieldInfo) as FieldDefinition;
if (field.IsCompilerGenerated() && field.DeclaringType == cecilProperty.DeclaringType)
{
RemoveCompilerGeneratedAttribute(property.Getter.Attributes);
RemoveCompilerGeneratedAttribute(property.Setter.Attributes);
property.Getter.Body = null;
property.Setter.Body = null;
}
// Add C# 7.3 attributes on backing field:
var attributes = fieldInfo.Attributes
.Where(a => !attributeTypesToRemoveFromAutoProperties.Any(t => t == a.AttributeType.FullName))
.Select(context.TypeSystemAstBuilder.ConvertAttribute).ToArray();
if (attributes.Length > 0)
{
var section = new AttributeSection {
AttributeTarget = "field"
};
section.Attributes.AddRange(attributes);
property.Attributes.Add(section);
}
// Since the property instance is not changed, we can continue in the visitor as usual, so return null
return(null);
}
/// <summary>
/// Adds an attribute section to a given entity.
/// </summary>
/// <param name="entity">The entity to add the attribute to.</param>
/// <param name="attr">The attribute to add.</param>
public void AddAttribute(EntityDeclaration entity, AttributeSection attr)
{
var node = entity.FirstChild;
while (node.NodeType == NodeType.Whitespace || node.Role == Roles.Attribute)
{
node = node.NextSibling;
}
InsertBefore(node, attr);
}
public override IUnresolvedEntity VisitAttributeSection(AttributeSection attributeSection, object data)
{
// non-assembly attributes are handled by their parent entity
if (attributeSection.AttributeTarget == "assembly") {
ConvertAttributes(parsedFile.AssemblyAttributes, attributeSection);
} else if (attributeSection.AttributeTarget == "module") {
ConvertAttributes(parsedFile.ModuleAttributes, attributeSection);
}
return null;
}
protected virtual IEnumerable <Syntax> TranslateAttributeSection(AttributeSection attributeSection, ILTranslationContext data)
{
foreach (var c in attributeSection.Children)
{
foreach (var cr in c.AcceptVisitor(this, data))
{
yield return(cr);
}
}
}
public override object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
TypeDeclaration typeDeclaration = (TypeDeclaration)methodDeclaration.Parent;
string testcase = "junit.framework.TestCase";
if (typeDeclaration != null && ((IsDerivedFrom(typeDeclaration, testcase) &&
!(typeDeclaration.Name.StartsWith("Abstract"))) || IsAllTestRunner(typeDeclaration.Name)))
{
if (methodDeclaration.Name == "main" || methodDeclaration.Name == "suite")
{
RemoveCurrentNode();
}
else if (methodDeclaration.Name.StartsWith("test"))
{
MethodDeclaration replaced = methodDeclaration;
Attribute attr = new Attribute("NUnit.Framework.Test", null, null);
List <Attribute> attributes = new List <Attribute>();
attributes.Add(attr);
AttributeSection testAttribute = new AttributeSection(null, attributes);
replaced.Attributes.Add(testAttribute);
AstUtil.RemoveModifierFrom(replaced, Modifiers.Static);
ReplaceCurrentNode(replaced);
}
else if (methodDeclaration.Name == "setUp" || methodDeclaration.Name == "tearDown")
{
if (Mode == "DotNet")
{
MethodDeclaration replaced = methodDeclaration;
replaced.Modifier = Modifiers.Public;
string attributeName = "NUnit.Framework.SetUp";
if (methodDeclaration.Name == "tearDown")
{
attributeName = "NUnit.Framework.TearDown";
}
Attribute attribute = new Attribute(attributeName, null, null);
List <Attribute> attributes = new List <Attribute>();
attributes.Add(attribute);
AttributeSection attributeSection = new AttributeSection(null, attributes);
replaced.Attributes.Add(attributeSection);
ReplaceCurrentNode(replaced);
}
else if (Mode == "IKVM")
{
methodDeclaration.Modifier = Modifiers.Protected | Modifiers.Override;
}
}
}
return(null);
}
public void PrevGen_Is_Skipped_Where_No_Template_Or_User_Exist()
{
Class cl = new Class(controller, "Class1");
cl.IsPartial = true;
cl.GenericTypes.Add("T");
Class c2 = new Class(controller, "Class2"); // Extra class in prevgen
AttributeSection attrs = new AttributeSection(controller);
Attribute attr = new Attribute(controller);
attr.PositionalArguments.Add("true");
attr.Name = "Serializable";
attrs.AddAttribute(attr);
cl.AddAttributeSection(attrs);
Namespace ns = new Namespace(controller);
ns.Name = "ArchAngel.Tests";
ns.AddChild(cl);
ns.AddChild(c2);
CodeRoot root = new CodeRoot(controller);
root.AddChild(ns);
CodeRootMap map = new CodeRootMap();
map.AddCodeRoot(root, Version.PrevGen);
cl = new Class(controller, "Class1");
cl.IsPartial = true;
cl.GenericTypes.Add("T");
attrs = new AttributeSection(controller);
attr = new Attribute(controller);
attr.PositionalArguments.Add("true");
attr.Name = "Serializable";
attrs.AddAttribute(attr);
cl.AddAttributeSection(attrs);
ns = new Namespace(controller);
ns.Name = "ArchAngel.Tests";
ns.AddChild(cl);
root = new CodeRoot(controller);
root.AddChild(ns);
map.AddCodeRoot(root, Version.User);
map.AddCodeRoot(root, Version.NewGen);
string result = map.GetMergedCodeRoot().ToString();
Assert.That(result, Is.EqualTo(root.ToString()));
Assertions.StringContains(result, "class Class1");
Assertions.StringContains(result, "[Serializable(true)]");
Assertions.StringContains(result, "namespace ArchAngel.Tests");
// make sure that the deleted class Class2 was not included int he merged code root.
Assertions.StringContains(result, "Class2", 0);
}
private static AttributeSection CreateAreaAttributeCode(string attributeName, string argumentName, Expression valueExpression)
{
NamedArgumentExpression argument = new NamedArgumentExpression(argumentName, valueExpression);
Attribute attribute = new Attribute(attributeName, new List <Expression>(), new List <NamedArgumentExpression>());
attribute.NamedArguments.Add(argument);
AttributeSection attributeSection = new AttributeSection("IDontKnow", new List <Attribute>());
attributeSection.Attributes.Add(attribute);
return(attributeSection);
}
public virtual object Visit(AttributeSection attributeSection, object data)
{
Debug.Assert(attributeSection != null);
Debug.Assert(attributeSection.Attributes != null);
foreach (ICSharpCode.NRefactory.Parser.AST.Attribute attribute in attributeSection.Attributes)
{
Debug.Assert(attribute != null);
attribute.AcceptVisitor(this, data);
}
return(data);
}
private AttributeSection CreateAttributeSection(string attributeName, List <Expression> args)
{
Attribute attribute = new Attribute(attributeName, args, null);
List <Attribute> attributes = new List <Attribute>();
attributes.Add(attribute);
AttributeSection attributeSection = new AttributeSection("", attributes);
attribute.Parent = attributeSection;
return(attributeSection);
}
public override object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
{
if (AstUtil.ContainsModifier(fieldDeclaration, Modifiers.Transient))
{
AttributeSection ats = CreateAttributeSection("System.NonSerializedAttribute", null);
FieldDeclaration replacedField = fieldDeclaration;
replacedField.Attributes.Add(ats);
ReplaceCurrentNode(replacedField);
}
return(base.TrackedVisitFieldDeclaration(fieldDeclaration, data));
}
/// <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);
}
public override void VisitAttributeSection(AttributeSection attributeSection)
{
if (attributeSection.AttributeTarget != "assembly")
{
return;
}
foreach (var attr in attributeSection.Attributes)
{
var name = attr.Type.ToString();
var resolveResult = this.Resolver.ResolveNode(attr, null);
var handled = //this.ReadAspect(attr, name, resolveResult, AttributeTargets.Assembly, null) ||
this.ReadModuleInfo(attr, name, resolveResult) ||
this.ReadFileNameInfo(attr, name, resolveResult) ||
this.ReadOutputPathInfo(attr, name, resolveResult) ||
this.ReadFileHierarchyInfo(attr, name, resolveResult) ||
this.ReadModuleDependency(attr, name, resolveResult);
}
}
IEnumerable<CodeAction> GetActions(Attribute attribute, AttributeSection attributeSection, FieldDeclaration fieldDeclaration)
{
string removeAttributeMessage = ctx.TranslateString("Remove attribute");
yield return new CodeAction(removeAttributeMessage, script => {
if (attributeSection.Attributes.Count > 1) {
var newSection = new AttributeSection();
newSection.AttributeTarget = attributeSection.AttributeTarget;
foreach (var attr in attributeSection.Attributes) {
if (attr != attribute)
newSection.Attributes.Add((Attribute)attr.Clone());
}
script.Replace(attributeSection, newSection);
} else {
script.Remove(attributeSection);
}
});
var makeStaticMessage = ctx.TranslateString("Make the field static");
yield return new CodeAction(makeStaticMessage, script => {
var newDeclaration = (FieldDeclaration)fieldDeclaration.Clone();
newDeclaration.Modifiers |= Modifiers.Static;
script.Replace(fieldDeclaration, newDeclaration);
});
}
private string Generate(String propertyName, String propertyTypeName, string indent)
{
// Create the attribute
AttributeSection attributeSection = new AttributeSection ();
var attribute = GetAttribute(Constants.OBJECTIVE_C_IVAR_SHORTFORM, propertyName);
attributeSection.Attributes.Add (attribute);
// Create the property declaration
PropertyDeclaration propertyDeclaration = GetPropertyDeclaration(propertyName, new SimpleType (propertyTypeName), attributeSection);
{
// Create the member this.GetInstanceVariable<T>
MemberReferenceExpression memberReferenceExpression = new MemberReferenceExpression (new ThisReferenceExpression (), "GetInstanceVariable");
memberReferenceExpression.TypeArguments.Add (new SimpleType (propertyTypeName));
// Create the invocation with arguments
InvocationExpression invocationExpression = new InvocationExpression (memberReferenceExpression, new List<Expression> { new PrimitiveExpression (propertyName) });
// Wrap the invocation with a return
ReturnStatement returnStatement = new ReturnStatement (invocationExpression);
// Create the "get" region
propertyDeclaration.Getter = new Accessor();
propertyDeclaration.Getter.Body = new BlockStatement ();
propertyDeclaration.Getter.Body.Add(returnStatement);
}
{
// Create the member this.SetInstanceVariable<T>
MemberReferenceExpression memberReferenceExpression = new MemberReferenceExpression (new ThisReferenceExpression (), "SetInstanceVariable");
memberReferenceExpression.TypeArguments.Add (new SimpleType (propertyTypeName));
// Create the invocation with arguments
InvocationExpression invocationExpression = new InvocationExpression (memberReferenceExpression, new List<Expression> { new PrimitiveExpression (propertyName), new IdentifierExpression ("value") });
// Wrap the invocation with an expression
ExpressionStatement expressionStatement = new ExpressionStatement (invocationExpression);
// Create the "set" region
propertyDeclaration.Setter = new Accessor();
propertyDeclaration.Setter.Body = new BlockStatement ();
propertyDeclaration.Setter.Body.Add(expressionStatement);
}
// Return the result of the AST generation
String generated = this.Options.OutputNode(propertyDeclaration);
// Add ident space
return Indent(generated, indent);
}
void GlobalAttributeSection() {
Expect(18);
#line 213 "cs.ATG"
Location startPos = t.Location;
Identifier();
#line 214 "cs.ATG"
if (t.val != "assembly" && t.val != "module") Error("global attribute target specifier (assembly or module) expected");
string attributeTarget = t.val;
List<ASTAttribute> attributes = new List<ASTAttribute>();
ASTAttribute attribute;
Expect(9);
Attribute(
#line 219 "cs.ATG"
out attribute);
#line 219 "cs.ATG"
attributes.Add(attribute);
while (
#line 220 "cs.ATG"
NotFinalComma()) {
Expect(14);
Attribute(
#line 220 "cs.ATG"
out attribute);
#line 220 "cs.ATG"
attributes.Add(attribute);
}
if (la.kind == 14) {
lexer.NextToken();
}
Expect(19);
#line 222 "cs.ATG"
AttributeSection section = new AttributeSection {
AttributeTarget = attributeTarget,
Attributes = attributes,
StartLocation = startPos,
EndLocation = t.EndLocation
};
compilationUnit.AddChild(section);
}
public void VisitAttributeSection(AttributeSection attributeSection)
{
JsonObject visit = new JsonObject();
visit.Comment = "VisitAttributeSection";
if (!string.IsNullOrEmpty(attributeSection.AttributeTarget))
{
visit.AddJsonValue("target", new JsonElement(attributeSection.AttributeTarget));
}
visit.AddJsonValue("attributes", GetCommaSeparatedList(attributeSection.Attributes));
Push(visit);
}
public void VisitAttributeSection(AttributeSection attributeSection)
{
StartNode(attributeSection);
WriteToken(Roles.LBracket);
if (!string.IsNullOrEmpty(attributeSection.AttributeTarget)) {
WriteToken(attributeSection.AttributeTarget, Roles.AttributeTargetRole);
WriteToken(Roles.Colon);
Space();
}
WriteCommaSeparatedList(attributeSection.Attributes);
WriteToken(Roles.RBracket);
if (attributeSection.Parent is ParameterDeclaration || attributeSection.Parent is TypeParameterDeclaration) {
Space();
} else {
NewLine();
}
EndNode(attributeSection);
}
AttributeSection ConvertAttributeSection(IEnumerable<Mono.CSharp.Attribute> optAttributes)
{
if (optAttributes == null)
return null;
var result = new AttributeSection();
var loc = LocationsBag.GetLocations(optAttributes);
int pos = 0;
if (loc != null)
result.AddChild(new CSharpTokenNode(Convert(loc [pos++]), Roles.LBracket), Roles.LBracket);
var first = optAttributes.FirstOrDefault();
string target = first != null ? first.ExplicitTarget : null;
if (!string.IsNullOrEmpty(target)) {
if (loc != null && pos < loc.Count - 1) {
result.AddChild(Identifier.Create(target, Convert(loc [pos++])), Roles.Identifier);
} else {
result.AddChild(Identifier.Create(target), Roles.Identifier);
}
if (loc != null && pos < loc.Count)
result.AddChild(new CSharpTokenNode(Convert(loc [pos++]), Roles.Colon), Roles.Colon);
}
int attributeCount = 0;
foreach (var attr in GetAttributes (optAttributes)) {
result.AddChild(attr, Roles.Attribute);
if (loc != null && pos + 1 < loc.Count)
result.AddChild(new CSharpTokenNode(Convert(loc [pos++]), Roles.Comma), Roles.Comma);
attributeCount++;
}
if (attributeCount == 0)
return null;
// Left and right bracket + commas between the attributes
int locCount = 2 + attributeCount - 1;
// optional comma
if (loc != null && pos < loc.Count - 1 && loc.Count == locCount + 1)
result.AddChild(new CSharpTokenNode(Convert(loc [pos++]), Roles.Comma), Roles.Comma);
if (loc != null && pos < loc.Count)
result.AddChild(new CSharpTokenNode(Convert(loc [pos++]), Roles.RBracket), Roles.RBracket);
return result;
}
void AddAttribute(DomRegion region, IAttribute attribute, string target = "")
{
var view = SD.FileService.OpenFile(new FileName(region.FileName), false);
var editor = view.GetRequiredService<ITextEditor>();
var context = SDRefactoringContext.Create(editor.FileName, editor.Document, region.Begin, CancellationToken.None);
var node = context.RootNode.GetNodeAt<EntityDeclaration>(region.Begin);
var resolver = context.GetResolverStateBefore(node);
var builder = new TypeSystemAstBuilder(resolver);
using (Script script = context.StartScript()) {
var attr = new AttributeSection();
attr.AttributeTarget = target;
attr.Attributes.Add(builder.ConvertAttribute(attribute));
script.InsertBefore(node, attr);
}
}
AttributeSection ConvertAttributeSection (List<Mono.CSharp.Attribute> optAttributes)
{
if (optAttributes == null)
return null;
AttributeSection result = new AttributeSection ();
var loc = LocationsBag.GetLocations (optAttributes);
if (loc != null)
result.AddChild (new CSharpTokenNode (Convert (loc [0]), 1), AttributeSection.Roles.LBracket);
result.AttributeTarget = optAttributes.First ().ExplicitTarget;
foreach (var attr in GetAttributes (optAttributes)) {
result.AddChild (attr, AttributeSection.AttributeRole);
}
if (loc != null)
result.AddChild (new CSharpTokenNode (Convert (loc [1]), 1), AttributeSection.Roles.RBracket);
return result;
}
void Bind(CXXRecordDecl baseDecl, CXXRecordDecl decl)
{
var name = decl.Name;
//Console.WriteLine(name);
bool isStruct = IsStructure (decl);
PushType(new TypeDeclaration
{
Name = RemapTypeName (decl.Name),
ClassType = isStruct ? ClassType.Struct : ClassType.Class,
Modifiers = Modifiers.Partial | Modifiers.Public | Modifiers.Unsafe
}, StringUtil.GetTypeComments(decl));
if (baseDecl != null) {
foreach (var baseType in decl.Bases) {
var baseName = baseType.Decl?.Name;
if (baseName == null)
continue;
// WorkItem is a structure, with a RefCount base class, avoid that
if (IsStructure(decl))
continue;
//
// Only a (File, MemoryBuffer, VectorBuffer)
// implement that, and the Serializer class is never
// surfaced as an API entry point, so we should just inline the methods
// from those classes into the generated class
//
if (baseName == "GPUObject" || baseName == "Thread" || baseName == "Octant" ||
baseName == "b2Draw" || baseName == "b2ContactListener" || baseName == "btIDebugDraw" || baseName == "btMotionState")
continue;
if (currentType.BaseTypes.Count > 0)
baseName = "I" + baseName;
currentType.BaseTypes.Add(new SimpleType(RemapTypeName(baseName)));
}
}
// Determines if this is a subclass of RefCounted (but not RefCounted itself)
bool refCountedSubclass = decl.TagKind == TagDeclKind.Class && decl.QualifiedName != "Urho3D::RefCounted" && decl.IsDerivedFrom(ScanBaseTypes.UrhoRefCounted);
// Same for Urho3D::Object
bool objectSubclass = decl.TagKind == TagDeclKind.Class && decl.QualifiedName != "Urho3D::Object" && decl.IsDerivedFrom(ScanBaseTypes.UrhoObjectType);
if (refCountedSubclass) {
var nativeCtor = new ConstructorDeclaration
{
Modifiers = Modifiers.Public,
Body = new BlockStatement(),
Initializer = new ConstructorInitializer()
};
nativeCtor.Parameters.Add(new ParameterDeclaration(new SimpleType("IntPtr"), "handle"));
nativeCtor.Initializer.Arguments.Add(new IdentifierExpression("handle"));
currentType.Members.Add(nativeCtor);
// The construtor with the emtpy chain flag
nativeCtor = new ConstructorDeclaration
{
Modifiers = Modifiers.Protected,
Body = new BlockStatement(),
Initializer = new ConstructorInitializer()
};
nativeCtor.Parameters.Add(new ParameterDeclaration(new SimpleType("UrhoObjectFlag"), "emptyFlag"));
nativeCtor.Initializer.Arguments.Add(new IdentifierExpression("emptyFlag"));
currentType.Members.Add(nativeCtor);
} else if (IsStructure(decl)) {
var serializable = new Attribute()
{
Type = new SimpleType("StructLayout")
};
serializable.Arguments.Add(new TypeReferenceExpression(new MemberType(new SimpleType("LayoutKind"), "Sequential")));
var attrs = new AttributeSection();
attrs.Attributes.Add(serializable);
currentType.Attributes.Add(attrs);
}
}
void AttributeSection(
#line 2596 "VBNET.ATG"
out AttributeSection section) {
#line 2598 "VBNET.ATG"
string attributeTarget = "";List<ASTAttribute> attributes = new List<ASTAttribute>();
ASTAttribute attribute;
Expect(28);
#line 2602 "VBNET.ATG"
Location startPos = t.Location;
if (
#line 2603 "VBNET.ATG"
IsLocalAttrTarget()) {
if (la.kind == 106) {
lexer.NextToken();
#line 2604 "VBNET.ATG"
attributeTarget = "event";
} else if (la.kind == 180) {
lexer.NextToken();
#line 2605 "VBNET.ATG"
attributeTarget = "return";
} else {
Identifier();
#line 2608 "VBNET.ATG"
string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
if (val != "field" || val != "method" ||
val != "module" || val != "param" ||
val != "property" || val != "type")
Error("attribute target specifier (event, return, field," +
"method, module, param, property, or type) expected");
attributeTarget = t.val;
}
Expect(11);
}
Attribute(
#line 2618 "VBNET.ATG"
out attribute);
#line 2618 "VBNET.ATG"
attributes.Add(attribute);
while (
#line 2619 "VBNET.ATG"
NotFinalComma()) {
Expect(12);
Attribute(
#line 2619 "VBNET.ATG"
out attribute);
#line 2619 "VBNET.ATG"
attributes.Add(attribute);
}
if (la.kind == 12) {
lexer.NextToken();
}
Expect(27);
#line 2623 "VBNET.ATG"
section = new AttributeSection {
AttributeTarget = attributeTarget,
Attributes = attributes,
StartLocation = startPos,
EndLocation = t.EndLocation
};
}
static void ConvertCustomAttributes(AstNode attributedNode, ICustomAttributeProvider customAttributeProvider, AttributeTarget target = AttributeTarget.None)
{
if (customAttributeProvider.HasCustomAttributes) {
var attributes = new List<ICSharpCode.NRefactory.CSharp.Attribute>();
foreach (var customAttribute in customAttributeProvider.CustomAttributes) {
var attribute = new ICSharpCode.NRefactory.CSharp.Attribute();
attribute.AddAnnotation(customAttribute);
attribute.Type = ConvertType(customAttribute.AttributeType);
attributes.Add(attribute);
SimpleType st = attribute.Type as SimpleType;
if (st != null && st.Identifier.EndsWith("Attribute", StringComparison.Ordinal)) {
st.Identifier = st.Identifier.Substring(0, st.Identifier.Length - "Attribute".Length);
}
if(customAttribute.HasConstructorArguments) {
foreach (var parameter in customAttribute.ConstructorArguments) {
Expression parameterValue = ConvertArgumentValue(parameter);
attribute.Arguments.Add(parameterValue);
}
}
if (customAttribute.HasProperties) {
TypeDefinition resolvedAttributeType = customAttribute.AttributeType.Resolve();
foreach (var propertyNamedArg in customAttribute.Properties) {
var propertyReference = resolvedAttributeType != null ? resolvedAttributeType.Properties.FirstOrDefault(pr => pr.Name == propertyNamedArg.Name) : null;
var propertyName = new IdentifierExpression(propertyNamedArg.Name).WithAnnotation(propertyReference);
var argumentValue = ConvertArgumentValue(propertyNamedArg.Argument);
attribute.Arguments.Add(new AssignmentExpression(propertyName, argumentValue));
}
}
if (customAttribute.HasFields) {
TypeDefinition resolvedAttributeType = customAttribute.AttributeType.Resolve();
foreach (var fieldNamedArg in customAttribute.Fields) {
var fieldReference = resolvedAttributeType != null ? resolvedAttributeType.Fields.FirstOrDefault(f => f.Name == fieldNamedArg.Name) : null;
var fieldName = new IdentifierExpression(fieldNamedArg.Name).WithAnnotation(fieldReference);
var argumentValue = ConvertArgumentValue(fieldNamedArg.Argument);
attribute.Arguments.Add(new AssignmentExpression(fieldName, argumentValue));
}
}
}
if (target == AttributeTarget.Module || target == AttributeTarget.Assembly) {
// use separate section for each attribute
foreach (var attribute in attributes) {
var section = new AttributeSection();
section.AttributeTarget = target;
section.Attributes.Add(attribute);
attributedNode.AddChild(section, AttributedNode.AttributeRole);
}
} else {
// use single section for all attributes
var section = new AttributeSection();
section.AttributeTarget = target;
section.Attributes.AddRange(attributes);
attributedNode.AddChild(section, AttributedNode.AttributeRole);
}
}
}
/// <summary>
/// Adds the linking attribute.
/// </summary>
/// <param name="contractClass">The contract class.</param>
private void AddLinkingAttribute(Class contractClass)
{
Contract.Requires(contractClass != null, "contractClass must not be null.");
var typeOfExp = new TypeOfExpression(new TypeReferenceExpression(this.InterfaceName));
var attribute = new CustomAttribute() { Name = ContractClassFor };
if (attribute.Arguments != null)
{
attribute.Arguments.Add(typeOfExp);
}
var section = new AttributeSection();
if (section.AttributeCollection != null)
{
section.AttributeCollection.Add(attribute);
}
contractClass.AddAttributeSection(section);
}
private String GenerateProperty(IProperty property, IMethod getterMethod, IMethod setterMethod)
{
// Create the property declaration
var propertyType = this.Options.CreateShortType (property.ReturnType);
PropertyDeclaration propertyDeclaration = this.GetPropertyDeclaration (property.Name, propertyType, null);
if (property.CanGet && getterMethod != null) {
// Retrieve the Objective-C message in the attribute
String message = AttributeHelper.GetAttributeValue (getterMethod, Constants.OBJECTIVE_C_MESSAGE);
AttributeSection attributeSection = new AttributeSection ();
if (!String.IsNullOrEmpty (message)) {
var attribute = this.GetAttribute (Constants.OBJECTIVE_C_MESSAGE_SHORTFORM, message);
attributeSection.Attributes.Add (attribute);
}
// Create the "get" region
ThrowStatement throwStatement = this.GetThrowStatement (Constants.NOT_IMPLEMENTED_EXCEPTION);
propertyDeclaration.Getter = new Accessor ();
propertyDeclaration.Getter.Attributes.Add (attributeSection);
propertyDeclaration.Getter.Body = new BlockStatement ();
propertyDeclaration.Getter.Body.Add (throwStatement);
}
if (property.CanSet && setterMethod != null) {
// Retrieve the Objective-C message in the attribute
String message = AttributeHelper.GetAttributeValue (setterMethod, Constants.OBJECTIVE_C_MESSAGE);
AttributeSection attributeSection = new AttributeSection ();
if (!String.IsNullOrEmpty (message)) {
var attribute = this.GetAttribute (Constants.OBJECTIVE_C_MESSAGE_SHORTFORM, message);
attributeSection.Attributes.Add (attribute);
}
// Create the "set" region
ThrowStatement throwStatement = this.GetThrowStatement (Constants.NOT_IMPLEMENTED_EXCEPTION);
propertyDeclaration.Setter = new Accessor ();
propertyDeclaration.Setter.Attributes.Add (attributeSection);
propertyDeclaration.Setter.Body = new BlockStatement ();
propertyDeclaration.Setter.Body.Add (throwStatement);
}
// Return the result of the AST generation
return this.Options.OutputNode (propertyDeclaration);
}
void GlobalAttributeSection() {
Expect(28);
#line 2521 "VBNET.ATG"
Location startPos = t.Location;
if (la.kind == 52) {
lexer.NextToken();
} else if (la.kind == 141) {
lexer.NextToken();
} else SynErr(226);
#line 2523 "VBNET.ATG"
string attributeTarget = t.val != null ? t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture) : null;
List<ASTAttribute> attributes = new List<ASTAttribute>();
ASTAttribute attribute;
Expect(11);
Attribute(
#line 2527 "VBNET.ATG"
out attribute);
#line 2527 "VBNET.ATG"
attributes.Add(attribute);
while (
#line 2528 "VBNET.ATG"
NotFinalComma()) {
if (la.kind == 12) {
lexer.NextToken();
if (la.kind == 52) {
lexer.NextToken();
} else if (la.kind == 141) {
lexer.NextToken();
} else SynErr(227);
Expect(11);
}
Attribute(
#line 2528 "VBNET.ATG"
out attribute);
#line 2528 "VBNET.ATG"
attributes.Add(attribute);
}
if (la.kind == 12) {
lexer.NextToken();
}
Expect(27);
EndOfStmt();
#line 2533 "VBNET.ATG"
AttributeSection section = new AttributeSection {
AttributeTarget = attributeTarget,
Attributes = attributes,
StartLocation = startPos,
EndLocation = t.EndLocation
};
compilationUnit.AddChild(section);
}
private String GenerateMethod(IMethod method)
{
// Retrieve the Objective-C message in the attribute
String message = AttributeHelper.GetAttributeValue (method, Constants.OBJECTIVE_C_MESSAGE);
AttributeSection attributeSection = new AttributeSection ();
if (!String.IsNullOrEmpty (message)) {
var attribute = this.GetAttribute (Constants.OBJECTIVE_C_MESSAGE_SHORTFORM, message);
attributeSection.Attributes.Add (attribute);
}
// Create the method declaration
MethodDeclaration methodDeclaration = new MethodDeclaration ();
methodDeclaration.Name = method.Name;
methodDeclaration.Attributes.Add (attributeSection);
methodDeclaration.Modifiers = Modifiers.Public | Modifiers.Virtual;
methodDeclaration.ReturnType = this.Options.CreateShortType (method.ReturnType);
foreach (var parameter in method.Parameters) {
ParameterDeclaration parameterDeclaration = new ParameterDeclaration (this.Options.CreateShortType (parameter.Type), parameter.Name);
if (parameter.IsOut) {
parameterDeclaration.ParameterModifier |= ParameterModifier.Out;
}
if (parameter.IsRef) {
parameterDeclaration.ParameterModifier |= ParameterModifier.Ref;
}
methodDeclaration.Parameters.Add (parameterDeclaration);
}
// Create the method body
methodDeclaration.Body = new BlockStatement ();
ThrowStatement throwStatement = this.GetThrowStatement (Constants.NOT_IMPLEMENTED_EXCEPTION);
methodDeclaration.Body.Add (throwStatement);
// Return the result of the AST generation
return this.Options.OutputNode (methodDeclaration);
}
protected PropertyDeclaration GetPropertyDeclaration(String name, AstType propertyType, AttributeSection attributeSection = null)
{
var declaration = new PropertyDeclaration();
declaration.Name = name;
declaration.Modifiers = Modifiers.Public | Modifiers.Virtual;
declaration.ReturnType = propertyType;
if (attributeSection != null) {
declaration.Attributes.Add(attributeSection);
}
IDELogger.Log("BaseRefactoringDialog::GetPropertyDeclaration -- {0}", declaration.Name);
return declaration;
}
/// <summary>
/// Creates an argfull stub for the specified implementation method.
/// </summary>
private MethodDeclaration CreateArgfull(MethodDeclaration template, bool skipThisParams, out bool hasThisParams)
{
hasThisParams = false;
MethodDeclaration method = new MethodDeclaration(template.Name, template.Modifier,
new TypeReference("Object"), new List<ParameterDeclarationExpression>(), new List<AttributeSection>());
method.Body = new BlockStatement();
Expression[] arguments = new Expression[template.Parameters.Count];
// prepend a ScriptContext parameter and make all parameters Objects
// (TODO: PhpReferences for ref parameters)
method.Parameters.Add(new ParameterDeclarationExpression(new TypeReference("ScriptContext"), "__context"));
int arg_counter = 0;
foreach (ParameterDeclarationExpression param in template.Parameters)
{
ParameterDeclarationExpression new_param =
new ParameterDeclarationExpression(new TypeReference("Object"), param.ParameterName);
bool optional = false;
if (Utility.IsDecoratedByAttribute(param.Attributes, Utility.OptionalAttrType))
{
AttributeSection section = new AttributeSection();
new_param.Attributes.Add(section);
section.Attributes.Add(new ICSharpCode.NRefactory.Parser.AST.Attribute(Utility.OptionalAttrType, null, null));
optional = true;
}
bool this_param = Utility.IsDecoratedByAttribute(param.Attributes, "PHP.Core.ThisAttribute");
if (this_param) hasThisParams = true;
if (this_param && skipThisParams)
{
arguments[arg_counter++] = new PrimitiveExpression(null, String.Empty);
}
else
{
// generate conversion
arguments[arg_counter++] = Convertor.ConvertTo(
template.Name,
new IdentifierExpression(param.ParameterName),
param.TypeReference,
method.Body,
new ReturnStatement(new PrimitiveExpression(null, String.Empty)),
Utility.IsDecoratedByAttribute(param.Attributes, "PHP.Core.NullableAttribute") || this_param,
optional,
arg_counter);
method.Parameters.Add(new_param);
}
}
// invoke the template method
InvocationExpression invocation = new InvocationExpression(new IdentifierExpression(template.Name),
new ArrayList(arguments));
if (template.TypeReference.SystemType == "System.Void")
{
method.Body.AddChild(new StatementExpression(invocation));
method.Body.AddChild(new ReturnStatement(new PrimitiveExpression(null, String.Empty)));
}
else method.Body.AddChild(new ReturnStatement(invocation));
if (!hasThisParams || skipThisParams) Utility.MakeNonBrowsable(method);
return method;
}
public VBAttributeSectionPrinter(AttributeSection obj)
{
this.obj = obj;
}
AttributeSection ConvertAttributeSection (List<Mono.CSharp.Attribute> optAttributes)
{
if (optAttributes == null)
return null;
AttributeSection result = new AttributeSection ();
var loc = LocationsBag.GetLocations (optAttributes);
int pos = 0;
if (loc != null)
result.AddChild (new CSharpTokenNode (Convert (loc [pos++]), 1), AttributeSection.Roles.LBracket);
string target = optAttributes.First ().ExplicitTarget;
if (!string.IsNullOrEmpty (target)) {
if (loc != null && pos < loc.Count - 1) {
result.AddChild (Identifier.Create (target, Convert (loc [pos++])), AttributeSection.Roles.Identifier);
} else {
result.AddChild (Identifier.Create (target), AttributeSection.Roles.Identifier);
}
if (loc != null && pos < loc.Count)
result.AddChild (new CSharpTokenNode (Convert (loc [pos++]), 1), AttributeSection.Roles.Colon);
}
foreach (var attr in GetAttributes (optAttributes)) {
result.AddChild (attr, AttributeSection.AttributeRole);
}
// optional comma
if (loc != null && pos < loc.Count - 1 && !loc [pos].Equals (loc [pos + 1]))
result.AddChild (new CSharpTokenNode (Convert (loc [pos++]), 1), AttributeSection.Roles.Comma);
if (loc != null && pos < loc.Count)
result.AddChild (new CSharpTokenNode (Convert (loc [pos++]), 1), AttributeSection.Roles.RBracket);
return result;
}
public virtual void VisitAttributeSection(AttributeSection attributeSection)
{
StartNode(attributeSection);
var braceHelper = BraceHelper.LeftBracket(this, CodeBracesRangeFlags.SquareBrackets);
if (!string.IsNullOrEmpty(attributeSection.AttributeTarget)) {
WriteKeyword(attributeSection.AttributeTarget, Roles.Identifier);
WriteToken(Roles.Colon, BoxedTextColor.Punctuation);
Space();
}
WriteCommaSeparatedList(attributeSection.Attributes);
braceHelper.RightBracket();
if (attributeSection.Parent is ParameterDeclaration || attributeSection.Parent is TypeParameterDeclaration) {
Space();
} else {
NewLine();
}
EndNode(attributeSection);
}
public virtual void VisitAttributeSection (AttributeSection attributeSection)
{
VisitChildren (attributeSection);
}
void AttributeSection(
#line 288 "cs.ATG"
out AttributeSection section) {
#line 290 "cs.ATG"
string attributeTarget = "";
List<ASTAttribute> attributes = new List<ASTAttribute>();
ASTAttribute attribute;
Expect(18);
#line 296 "cs.ATG"
Location startPos = t.Location;
if (
#line 297 "cs.ATG"
IsLocalAttrTarget()) {
if (la.kind == 69) {
lexer.NextToken();
#line 298 "cs.ATG"
attributeTarget = "event";
} else if (la.kind == 101) {
lexer.NextToken();
#line 299 "cs.ATG"
attributeTarget = "return";
} else {
Identifier();
#line 300 "cs.ATG"
if (t.val != "field" && t.val != "method" &&
t.val != "param" &&
t.val != "property" && t.val != "type")
Error("attribute target specifier (field, event, method, param, property, return or type) expected");
attributeTarget = t.val;
}
Expect(9);
}
Attribute(
#line 309 "cs.ATG"
out attribute);
#line 309 "cs.ATG"
attributes.Add(attribute);
while (
#line 310 "cs.ATG"
NotFinalComma()) {
Expect(14);
Attribute(
#line 310 "cs.ATG"
out attribute);
#line 310 "cs.ATG"
attributes.Add(attribute);
}
if (la.kind == 14) {
lexer.NextToken();
}
Expect(19);
#line 312 "cs.ATG"
section = new AttributeSection {
AttributeTarget = attributeTarget,
Attributes = attributes,
StartLocation = startPos,
EndLocation = t.EndLocation
};
}
/// <summary>
/// Adds an attribute section to a given entity.
/// </summary>
/// <param name="entity">The entity to add the attribute to.</param>
/// <param name="attr">The attribute to add.</param>
public void AddAttribute(EntityDeclaration entity, AttributeSection attr)
{
var node = entity.FirstChild;
while (node.NodeType == NodeType.Whitespace || node.Role == Roles.Attribute) {
node = node.NextSibling;
}
InsertBefore(node, attr);
}
public StringBuilder VisitAttributeSection(AttributeSection attributeSection, int data)
{
throw new SLSharpException("HLSL does not have attributes.");
}