void AddTypeParameters(AstNode parent, MemberName memberName)
{
if (memberName == null || memberName.TypeParameters == null)
return;
var chevronLocs = LocationsBag.GetLocations(memberName.TypeParameters);
if (chevronLocs != null)
parent.AddChild(new CSharpTokenNode(Convert(chevronLocs [chevronLocs.Count - 2]), Roles.LChevron), Roles.LChevron);
for (int i = 0; i < memberName.TypeParameters.Count; i++) {
if (chevronLocs != null && i > 0 && i - 1 < chevronLocs.Count)
parent.AddChild(new CSharpTokenNode(Convert(chevronLocs [i - 1]), Roles.Comma), Roles.Comma);
var arg = memberName.TypeParameters [i];
if (arg == null)
continue;
var tp = new TypeParameterDeclaration();
List<Location> varianceLocation;
switch (arg.Variance) {
case Variance.Contravariant:
tp.Variance = VarianceModifier.Contravariant;
varianceLocation = LocationsBag.GetLocations(arg);
if (varianceLocation != null)
tp.AddChild(new CSharpTokenNode(Convert(varianceLocation [0]), TypeParameterDeclaration.InVarianceKeywordRole), TypeParameterDeclaration.InVarianceKeywordRole);
break;
case Variance.Covariant:
tp.Variance = VarianceModifier.Covariant;
varianceLocation = LocationsBag.GetLocations(arg);
if (varianceLocation != null)
tp.AddChild(new CSharpTokenNode(Convert(varianceLocation [0]), TypeParameterDeclaration.OutVarianceKeywordRole), TypeParameterDeclaration.OutVarianceKeywordRole);
break;
default:
tp.Variance = VarianceModifier.Invariant;
break;
}
AddAttributeSection(tp, arg.OptAttributes);
switch (arg.Variance) {
case Variance.Covariant:
tp.Variance = VarianceModifier.Covariant;
break;
case Variance.Contravariant:
tp.Variance = VarianceModifier.Contravariant;
break;
}
tp.AddChild(Identifier.Create(arg.Name, Convert(arg.Location)), Roles.Identifier);
parent.AddChild(tp, Roles.TypeParameter);
}
if (chevronLocs != null)
parent.AddChild(new CSharpTokenNode(Convert(chevronLocs [chevronLocs.Count - 1]), Roles.RChevron), Roles.RChevron);
}
void AddArguments(AstNode parent, Arguments args)
{
if (args == null)
return;
var commaLocations = LocationsBag.GetLocations(args);
for (int i = 0; i < args.Count; i++) {
parent.AddChild(ConvertArgument(args [i]), Roles.Argument);
if (commaLocations != null && i < commaLocations.Count) {
parent.AddChild(new CSharpTokenNode(Convert(commaLocations [i]), Roles.Comma), Roles.Comma);
}
}
if (commaLocations != null && commaLocations.Count > args.Count)
parent.AddChild(new CSharpTokenNode(Convert(commaLocations [args.Count]), Roles.Comma), Roles.Comma);
}
void AddConstraints(AstNode parent, TypeParameters d)
{
if (d == null)
return;
for (int i = d.Count - 1; i >= 0; i--) {
var typeParameter = d [i];
if (typeParameter == null)
continue;
var c = typeParameter.Constraints;
if (c == null)
continue;
var location = LocationsBag.GetLocations (c);
var constraint = new Constraint ();
constraint.AddChild (new CSharpTokenNode (Convert (c.Location), Roles.WhereKeyword), Roles.WhereKeyword);
constraint.AddChild (new SimpleType (Identifier.Create (c.TypeParameter.Value, Convert (c.TypeParameter.Location))), Roles.ConstraintTypeParameter);
if (location != null)
constraint.AddChild (new CSharpTokenNode (Convert (location [0]), Roles.Colon), Roles.Colon);
var commaLocs = LocationsBag.GetLocations (c.ConstraintExpressions);
int curComma = 0;
if (c.ConstraintExpressions != null) {
foreach (var expr in c.ConstraintExpressions) {
constraint.AddChild (ConvertToType (expr), Roles.BaseType);
if (commaLocs != null && curComma < commaLocs.Count)
constraint.AddChild (new CSharpTokenNode (Convert (commaLocs [curComma++]), Roles.Comma), Roles.Comma);
}
}
parent.AddChild (constraint, Roles.Constraint);
}
}
void AddExplicitInterface(AstNode parent, MemberName memberName)
{
if (memberName == null || memberName.ExplicitInterface == null)
return;
parent.AddChild(ConvertToType(memberName.ExplicitInterface), EntityDeclaration.PrivateImplementationTypeRole);
var privateImplTypeLoc = LocationsBag.GetLocations(memberName.ExplicitInterface);
if (privateImplTypeLoc != null)
parent.AddChild(new CSharpTokenNode(Convert(privateImplTypeLoc [0]), Roles.Dot), Roles.Dot);
}
public void AddAttributeSection (AstNode parent, Attributable a)
{
if (a.OptAttributes == null)
return;
foreach (var attr in a.OptAttributes.Sections) {
parent.AddChild (ConvertAttributeSection (attr), AttributedNode.AttributeRole);
}
}
void AddTypeArguments (AstNode parent, Mono.CSharp.TypeArguments typeArguments)
{
if (typeArguments == null || typeArguments.IsEmpty)
return;
var chevronLocs = LocationsBag.GetLocations (typeArguments);
if (chevronLocs != null)
parent.AddChild (new CSharpTokenNode (Convert (chevronLocs[chevronLocs.Count - 2]), 1), InvocationExpression.Roles.LChevron);
for (int i = 0; i < typeArguments.Count; i++) {
var arg = typeArguments.Args[i];
if (arg == null)
continue;
parent.AddChild (ConvertToType (arg), InvocationExpression.Roles.TypeArgument);
if (chevronLocs != null && i < chevronLocs.Count - 2)
parent.AddChild (new CSharpTokenNode (Convert (chevronLocs[i]), 1), InvocationExpression.Roles.Comma);
}
if (chevronLocs != null)
parent.AddChild (new CSharpTokenNode (Convert (chevronLocs[chevronLocs.Count - 1]), 1), InvocationExpression.Roles.RChevron);
}
void AddTypeParameters (AstNode parent, List<Location> location, Mono.CSharp.TypeArguments typeArguments)
{
if (typeArguments == null || typeArguments.IsEmpty)
return;
for (int i = 0; i < typeArguments.Count; i++) {
if (location != null && i > 0 && i - 1 < location.Count)
parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
var arg = (TypeParameterName)typeArguments.Args[i];
if (arg == null)
continue;
TypeParameterDeclaration tp = new TypeParameterDeclaration();
// TODO: attributes
if (arg.Variance != Variance.None)
throw new NotImplementedException(); // TODO: variance
tp.AddChild (new Identifier (arg.Name, Convert (arg.Location)), InvocationExpression.Roles.Identifier);
parent.AddChild (tp, InvocationExpression.Roles.TypeParameter);
}
}
void AddTypeArguments (AstNode parent, List<Location> location, Mono.CSharp.TypeArguments typeArguments)
{
if (typeArguments == null || typeArguments.IsEmpty)
return;
for (int i = 0; i < typeArguments.Count; i++) {
if (location != null && i > 0 && i - 1 < location.Count)
parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
var arg = typeArguments.Args[i];
if (arg == null)
continue;
parent.AddChild (ConvertToType (arg), InvocationExpression.Roles.TypeArgument);
}
}
void ParseSnippetEffect(AstNode parent)
{
SnippetEffect def = new SnippetEffect(CurrentToken);
parent.AddChild(def);
}
void AddConstraints (AstNode parent, DeclSpace d)
{
if (d == null || d.Constraints == null)
return;
for (int i = 0; i < d.PlainConstraints.Count; i++) {
Constraints c = d.PlainConstraints [i];
var location = LocationsBag.GetLocations (c);
var constraint = new Constraint ();
if (location != null)
constraint.AddChild (new CSharpTokenNode (Convert (location [0]), "where".Length), InvocationExpression.Roles.Keyword);
constraint.AddChild (new Identifier (c.TypeParameter.Value, Convert (c.TypeParameter.Location)), InvocationExpression.Roles.Identifier);
if (location != null && location.Count > 1)
constraint.AddChild (new CSharpTokenNode (Convert (location [1]), 1), Constraint.ColonRole);
foreach (var expr in c.ConstraintExpressions)
constraint.AddChild (ConvertToType (expr), Constraint.BaseTypeRole);
parent.AddChild (constraint, AstNode.Roles.Constraint);
}
}
public void TryGenerateCode()
{
AstNode root = GetRoot();
foreach (var item in root.Children)
{
Debug.Log(item);
}
if (root.Descendants.OfType <UsingDeclaration>().Where(x => x.Namespace == "System").Count() == 0)
{
root.AddChild <AstNode>(new UsingDeclaration("System"), Roles.Root);
}
if (root.Descendants.OfType <UsingDeclaration>().Where(x => x.Namespace == "UnityEngine").Count() == 0)
{
root.AddChild <AstNode>(new UsingDeclaration("UnityEngine"), Roles.Root);
}
TypeDeclaration classNode = null;
if (root.Descendants.OfType <TypeDeclaration>().Where(x => x.Name == "DemoClass").Count() != 0)
{
classNode = root.Descendants.OfType <TypeDeclaration>().Where(x => x.Name == "DemoClass").First();
}
else
{
classNode = new TypeDeclaration();
classNode.Name = "DemoClass";
classNode.Modifiers = Modifiers.Public;
var comment = new Comment("<summary>", CommentType.Documentation);
root.AddChild(comment, Roles.Comment);
comment = new Comment("代码说明信息", CommentType.Documentation);
root.AddChild(comment, Roles.Comment);
comment = new Comment("<summary>", CommentType.Documentation);
root.AddChild(comment, Roles.Comment);
root.AddChild(classNode, Roles.TypeMemberRole);
}
if (classNode.Descendants.OfType <FieldDeclaration>().Where(x => x.Variables.Where(y => y.Name == "DemoField").Count() > 0).Count() == 0)
{
var field = new FieldDeclaration();
field.Modifiers = Modifiers.Public;
field.ReturnType = new BridgeUI.NRefactory.CSharp.PrimitiveType("int");
field.Variables.Add(new VariableInitializer("DemoField", new IdentifierExpression("0")));
classNode.AddChild(field, Roles.TypeMemberRole);
}
if (classNode.Descendants.OfType <ConstructorDeclaration>().Where(x => x.Name == "DemoClass").Count() == 0)
{
var constractNode = new ConstructorDeclaration();
constractNode.Modifiers = Modifiers.Public;
constractNode.Name = "DemoClass";
var statement = new BlockStatement();
statement.Add(new AssignmentExpression(new IdentifierExpression("DemoField"), new PrimitiveExpression(1)));
constractNode.Body = statement;
classNode.AddChild(constractNode, Roles.TypeMemberRole);
}
if (classNode.Descendants.OfType <MethodDeclaration>().Where(x => x.Name == "DemoFunction").Count() == 0)
{
var mainFuncNode = new MethodDeclaration();
mainFuncNode.Modifiers = Modifiers.Public;
mainFuncNode.Name = "DemoFunction";
mainFuncNode.ReturnType = new BridgeUI.NRefactory.CSharp.PrimitiveType("void");
var parameter1 = new ParameterDeclaration();
parameter1.Type = new BridgeUI.NRefactory.CSharp.PrimitiveType("int");
parameter1.Name = "arg1";
mainFuncNode.Parameters.Add(parameter1);
var statement = new BlockStatement();
statement.Add(new InvocationExpression(new MemberReferenceExpression(new IdentifierExpression("Debug"), "Log", new AstType[0]), new PrimitiveExpression("Hellow World")));
mainFuncNode.Body = statement;
var parameter2 = new ParameterDeclaration();
//parameter2.Type = new BridgeUI.NRefactory.CSharp.PrimitiveType("int[]");
var type = new ComposedType();
type.ArraySpecifiers.Add(new ArraySpecifier());
type.BaseType = new BridgeUI.NRefactory.CSharp.PrimitiveType("int");
type.HasNullableSpecifier = true;
parameter2.Type = type;
parameter2.Name = "arg2";
mainFuncNode.Parameters.Add(parameter2);
classNode.AddChild(mainFuncNode, Roles.TypeMemberRole);
}
Debug.Log(root.ToString());
SaveToAssetFolder(root.ToString());
}
public void Run (AstNode compilationUnit)
{
var ns = compilationUnit.Children.OfType<NamespaceDeclaration> ();
foreach (var d in ns.SelectMany (x => x.Members)) {
d.Remove ();
compilationUnit.AddChild (d, SyntaxTree.MemberRole);
}
foreach (var n in ns) {
n.Remove ();
}
}
/* program -> ( expr )*
*/
public AstNode Program() {
AstNode programNode = new AstNode(AstNodeType.PROGRAM);
while (!End)
programNode.AddChild(Expr());
return programNode;
}
/* expr -> "print" term
| "input" IDENT
| IDENT "=" term
| "if" "(" add ")" "then" expr "else" expr
| "while" "(" add ")" expr
*/
public AstNode Expr() {
if (IsMatch("print")) {
Match("print");
AstNode value = Term();
return new AstNode(AstNodeType.PRINT, value);
}
else if (IsMatch("input")) {
Match("input");
AstNode identifier = IDENT();
return new AstNode(AstNodeType.INPUT, identifier);
}
else if (IsMatch("if"))
{
Match("if");
Match("(");
AstNode ifNode = new AstNode(AstNodeType.IF, Term());
Match(")");
Match("then");
ifNode.AddChild(Expr());
if (IsMatch("else"))
{
Match("else");
ifNode.AddChild(Expr());
}
return ifNode;
}
else if (IsMatch("while"))
{
Match("while");
Match("(");
AstNode whileNode = new AstNode(AstNodeType.WHILE, Term());
Match(")");
whileNode.AddChild(Expr());
return whileNode;
}
else
{
AstNode identifier = IDENT();
Match("=");
AstNode value = Term();
return new AstNode(AstNodeType.ASSIGN, identifier, value);
}
}
void AddParameter (AstNode parent, Mono.CSharp.AParametersCollection parameters)
{
if (parameters == null)
return;
var paramLocation = LocationsBag.GetLocations (parameters);
for (int i = 0; i < parameters.Count; i++) {
if (paramLocation != null && i > 0 && i - 1 < paramLocation.Count)
parent.AddChild (new CSharpTokenNode (Convert (paramLocation[i - 1]), 1), ParameterDeclaration.Roles.Comma);
var p = (Parameter)parameters.FixedParameters[i];
var location = LocationsBag.GetLocations (p);
ParameterDeclaration parameterDeclarationExpression = new ParameterDeclaration ();
switch (p.ModFlags) {
case Parameter.Modifier.OUT:
parameterDeclarationExpression.ParameterModifier = ParameterModifier.Out;
if (location != null)
parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), "out".Length), ParameterDeclaration.Roles.Keyword);
break;
case Parameter.Modifier.REF:
parameterDeclarationExpression.ParameterModifier = ParameterModifier.Ref;
if (location != null)
parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), "ref".Length), ParameterDeclaration.Roles.Keyword);
break;
case Parameter.Modifier.PARAMS:
parameterDeclarationExpression.ParameterModifier = ParameterModifier.Params;
if (location != null)
parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), "params".Length), ParameterDeclaration.Roles.Keyword);
break;
case Parameter.Modifier.This:
parameterDeclarationExpression.ParameterModifier = ParameterModifier.This;
if (location != null)
parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), "this".Length), ParameterDeclaration.Roles.Keyword);
break;
}
if (p.TypeExpression != null) // lambdas may have no types (a, b) => ...
parameterDeclarationExpression.AddChild ((AstNode)p.TypeExpression.Accept (this), ParameterDeclaration.Roles.ReturnType);
parameterDeclarationExpression.AddChild (new Identifier (p.Name, Convert (p.Location)), ParameterDeclaration.Roles.Identifier);
if (p.HasDefaultValue) {
if (location != null)
parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ParameterDeclaration.Roles.Assign);
parameterDeclarationExpression.AddChild ((AstNode)p.DefaultValue.Accept (this), ParameterDeclaration.Roles.Expression);
}
parent.AddChild (parameterDeclarationExpression, InvocationExpression.Roles.Parameter);
}
}
void AddTypeParameters (AstNode parent, List<Location> location, Mono.CSharp.TypeArguments typeArguments)
{
if (typeArguments == null || typeArguments.IsEmpty)
return;
for (int i = 0; i < typeArguments.Count; i++) {
if (location != null && i > 0 && i - 1 < location.Count)
parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
var arg = (TypeParameterName)typeArguments.Args[i];
if (arg == null)
continue;
TypeParameterDeclaration tp = new TypeParameterDeclaration();
// TODO: attributes
switch (arg.Variance) {
case Variance.Covariant:
tp.Variance = VarianceModifier.Covariant;
break;
case Variance.Contravariant:
tp.Variance = VarianceModifier.Contravariant;
break;
}
tp.AddChild (Identifier.Create (arg.Name, Convert (arg.Location)), InvocationExpression.Roles.Identifier);
parent.AddChild (tp, InvocationExpression.Roles.TypeParameter);
}
}
void AddTypeArguments (AstNode parent, LocationsBag.MemberLocations location, Mono.CSharp.TypeArguments typeArguments)
{
if (typeArguments == null || typeArguments.IsEmpty)
return;
for (int i = 0; i < typeArguments.Count; i++) {
if (location != null && i > 0 && i - 1 < location.Count)
parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
var arg = typeArguments.Args[i];
if (arg == null)
continue;
parent.AddChild ((AstNode)arg.Accept (this), InvocationExpression.Roles.TypeParameter);
}
}
void AddArguments (AstNode parent, object location, Mono.CSharp.Arguments args)
{
if (args == null)
return;
var commaLocations = LocationsBag.GetLocations (args);
for (int i = 0; i < args.Count; i++) {
parent.AddChild (ConvertArgument (args[i]), InvocationExpression.Roles.Argument);
if (commaLocations != null && i > 0) {
int idx = commaLocations.Count - i;
if (idx >= 0)
parent.AddChild (new CSharpTokenNode (Convert (commaLocations[idx]), 1), InvocationExpression.Roles.Comma);
}
}
if (commaLocations != null && commaLocations.Count > args.Count)
parent.AddChild (new CSharpTokenNode (Convert (commaLocations[0]), 1), InvocationExpression.Roles.Comma);
}
void AddConstraints (AstNode parent, DeclSpace d)
{
if (d == null || d.Constraints == null)
return;
for (int i = 0; i < d.Constraints.Count; i++) {
Constraints c = d.Constraints[i];
var location = LocationsBag.GetLocations (c);
// var constraint = new Constraint ();
parent.AddChild (new CSharpTokenNode (Convert (location[0]), "where".Length), InvocationExpression.Roles.Keyword);
parent.AddChild (new Identifier (c.TypeParameter.Value, Convert (c.TypeParameter.Location)), InvocationExpression.Roles.Identifier);
parent.AddChild (new CSharpTokenNode (Convert (location[1]), 1), InvocationExpression.Roles.Colon);
foreach (var expr in c.ConstraintExpressions)
parent.AddChild ((AstNode)expr.Accept (this), InvocationExpression.Roles.TypeParameter);
}
}
void AddTypeParameters (AstNode parent, Mono.CSharp.TypeArguments typeArguments)
{
if (typeArguments == null || typeArguments.IsEmpty)
return;
var chevronLocs = LocationsBag.GetLocations (typeArguments);
if (chevronLocs != null)
parent.AddChild (new CSharpTokenNode (Convert (chevronLocs[chevronLocs.Count - 2]), 1), InvocationExpression.Roles.LChevron);
for (int i = 0; i < typeArguments.Count; i++) {
if (chevronLocs != null && i > 0 && i - 1 < chevronLocs.Count)
parent.AddChild (new CSharpTokenNode (Convert (chevronLocs[i - 1]), 1), InvocationExpression.Roles.Comma);
var arg = (TypeParameterName)typeArguments.Args[i];
if (arg == null)
continue;
TypeParameterDeclaration tp = new TypeParameterDeclaration();
List<Location> varianceLocation;
switch (arg.Variance) {
case Variance.Contravariant:
tp.Variance = VarianceModifier.Contravariant;
varianceLocation = LocationsBag.GetLocations (arg);
if (varianceLocation != null)
tp.AddChild (new CSharpTokenNode (Convert (varianceLocation[0]), "out".Length), TypeParameterDeclaration.VarianceRole);
break;
case Variance.Covariant:
tp.Variance = VarianceModifier.Covariant;
varianceLocation = LocationsBag.GetLocations (arg);
if (varianceLocation != null)
tp.AddChild (new CSharpTokenNode (Convert (varianceLocation[0]), "out".Length), TypeParameterDeclaration.VarianceRole);
break;
default:
tp.Variance = VarianceModifier.Invariant;
break;
}
AddAttributeSection (tp, arg.OptAttributes);
switch (arg.Variance) {
case Variance.Covariant:
tp.Variance = VarianceModifier.Covariant;
break;
case Variance.Contravariant:
tp.Variance = VarianceModifier.Contravariant;
break;
}
tp.AddChild (Identifier.Create (arg.Name, Convert (arg.Location)), InvocationExpression.Roles.Identifier);
parent.AddChild (tp, InvocationExpression.Roles.TypeParameter);
}
if (chevronLocs != null)
parent.AddChild (new CSharpTokenNode (Convert (chevronLocs[chevronLocs.Count - 1]), 1), InvocationExpression.Roles.RChevron);
}
void AddArguments (AstNode parent, object location, Mono.CSharp.Arguments args)
{
if (args == null)
return;
var commaLocations = LocationsBag.GetLocations (args);
for (int i = 0; i < args.Count; i++) {
Argument arg = args[i];
if (arg.ArgType == Argument.AType.Out || arg.ArgType == Argument.AType.Ref) {
DirectionExpression direction = new DirectionExpression ();
direction.FieldDirection = arg.ArgType == Argument.AType.Out ? FieldDirection.Out : FieldDirection.Ref;
var argLocation = LocationsBag.GetLocations (arg);
if (location != null)
direction.AddChild (new CSharpTokenNode (Convert (argLocation[0]), "123".Length), InvocationExpression.Roles.Keyword);
direction.AddChild ((AstNode)arg.Expr.Accept (this), InvocationExpression.Roles.Expression);
parent.AddChild (direction, InvocationExpression.Roles.Parameter);
} else {
parent.AddChild ((AstNode)arg.Expr.Accept (this), InvocationExpression.Roles.Parameter);
}
if (commaLocations != null && i > 0) {
int idx = commaLocations.Count - i;
if (idx >= 0)
parent.AddChild (new CSharpTokenNode (Convert (commaLocations[idx]), 1), InvocationExpression.Roles.Comma);
}
}
if (commaLocations != null && commaLocations.Count > args.Count)
parent.AddChild (new CSharpTokenNode (Convert (commaLocations[0]), 1), InvocationExpression.Roles.Comma);
}
void AddConstraints (AstNode parent, DeclSpace d)
{
if (d == null || d.Constraints == null)
return;
for (int i = 0; i < d.PlainConstraints.Count; i++) {
Constraints c = d.PlainConstraints [i];
var location = LocationsBag.GetLocations (c);
var constraint = new Constraint ();
constraint.AddChild (new CSharpTokenNode (Convert (c.Location), "where".Length), InvocationExpression.Roles.Keyword);
constraint.AddChild (new SimpleType (Identifier.Create (c.TypeParameter.Value, Convert (c.TypeParameter.Location))), Constraint.TypeParameterRole);
if (location != null)
constraint.AddChild (new CSharpTokenNode (Convert (location [0]), 1), Constraint.ColonRole);
var commaLocs = LocationsBag.GetLocations (c.ConstraintExpressions);
int curComma = 0;
foreach (var expr in c.ConstraintExpressions) {
constraint.AddChild (ConvertToType (expr), Constraint.BaseTypeRole);
if (commaLocs != null && curComma < commaLocs.Count)
constraint.AddChild (new CSharpTokenNode (Convert (commaLocs[curComma++]), 1), InvocationExpression.Roles.Comma);
}
parent.AddChild (constraint, AstNode.Roles.Constraint);
}
}
public static void InsertComment (AstNode node, MonoDevelop.CSharp.Ast.Comment comment)
{
if (node.EndLocation < comment.StartLocation) {
node.AddChild (comment);
return;
}
foreach (var child in node.Children) {
if (child.StartLocation < comment.StartLocation && comment.StartLocation < child.EndLocation) {
InsertComment (child, comment);
return;
}
if (comment.StartLocation < child.StartLocation) {
node.InsertChildBefore (child, comment, AstNode.Roles.Comment);
return;
}
}
node.AddChild (comment);
}
public void AddAttributeSection(AstNode parent, Attributes attrs, Role role)
{
if (attrs == null)
return;
foreach (var attr in attrs.Sections) {
parent.AddChild (ConvertAttributeSection (attr), EntityDeclaration.AttributeRole);
}
}
void AddModifiers (AstNode parent, LocationsBag.MemberLocations location)
{
if (location == null || location.Modifiers == null)
return;
foreach (var modifier in location.Modifiers) {
parent.AddChild (new CSharpModifierToken (Convert (modifier.Item2), modifierTable[modifier.Item1]), AstNode.Roles.Modifier);
}
}
void AddParameter(AstNode parent, AParametersCollection parameters)
{
if (parameters == null)
return;
var paramLocation = LocationsBag.GetLocations(parameters);
for (int i = 0; i < parameters.Count; i++) {
var p = (Parameter)parameters.FixedParameters [i];
if (p == null)
continue;
var location = LocationsBag.GetLocations(p);
var parameterDeclarationExpression = new ParameterDeclaration();
AddAttributeSection(parameterDeclarationExpression, p);
switch (p.ModFlags) {
case Parameter.Modifier.OUT:
parameterDeclarationExpression.ParameterModifier = ParameterModifier.Out;
if (location != null)
parameterDeclarationExpression.AddChild(new CSharpTokenNode(Convert(location [0]), ParameterDeclaration.OutModifierRole), ParameterDeclaration.OutModifierRole);
break;
case Parameter.Modifier.REF:
parameterDeclarationExpression.ParameterModifier = ParameterModifier.Ref;
if (location != null)
parameterDeclarationExpression.AddChild(new CSharpTokenNode(Convert(location [0]), ParameterDeclaration.RefModifierRole), ParameterDeclaration.RefModifierRole);
break;
case Parameter.Modifier.PARAMS:
parameterDeclarationExpression.ParameterModifier = ParameterModifier.Params;
if (location != null)
parameterDeclarationExpression.AddChild(new CSharpTokenNode(Convert(location [0]), ParameterDeclaration.ParamsModifierRole), ParameterDeclaration.ParamsModifierRole);
break;
default:
if (p.HasExtensionMethodModifier) {
parameterDeclarationExpression.ParameterModifier = ParameterModifier.This;
if (location != null) {
parameterDeclarationExpression.AddChild(new CSharpTokenNode(Convert(location [0]), ParameterDeclaration.ThisModifierRole), ParameterDeclaration.ThisModifierRole);
}
}
break;
}
if (p.TypeExpression != null) // lambdas may have no types (a, b) => ...
parameterDeclarationExpression.AddChild(ConvertToType(p.TypeExpression), Roles.Type);
if (p.Name != null)
parameterDeclarationExpression.AddChild(Identifier.Create(p.Name, Convert(p.Location)), Roles.Identifier);
if (p.HasDefaultValue) {
if (location != null && location.Count > 1)
parameterDeclarationExpression.AddChild(new CSharpTokenNode(Convert(location [1]), Roles.Assign), Roles.Assign);
parameterDeclarationExpression.AddChild((Expression)p.DefaultValue.Accept(this), Roles.Expression);
}
parent.AddChild(parameterDeclarationExpression, Roles.Parameter);
if (paramLocation != null && i < paramLocation.Count) {
parent.AddChild(new CSharpTokenNode(Convert(paramLocation [i]), Roles.Comma), Roles.Comma);
}
}
}
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);
}
}
}
void AddTypeArguments(AstNode parent, ATypeNameExpression memberName)
{
if (memberName == null || !memberName.HasTypeArguments)
return;
var chevronLocs = LocationsBag.GetLocations(memberName.TypeArguments);
if (chevronLocs != null)
parent.AddChild(new CSharpTokenNode(Convert(chevronLocs [chevronLocs.Count - 2]), Roles.LChevron), Roles.LChevron);
for (int i = 0; i < memberName.TypeArguments.Count; i++) {
var arg = memberName.TypeArguments.Args [i];
if (arg == null)
continue;
parent.AddChild(ConvertToType(arg), Roles.TypeArgument);
if (chevronLocs != null && i < chevronLocs.Count - 2)
parent.AddChild(new CSharpTokenNode(Convert(chevronLocs [i]), Roles.Comma), Roles.Comma);
}
if (chevronLocs != null)
parent.AddChild(new CSharpTokenNode(Convert(chevronLocs [chevronLocs.Count - 1]), Roles.RChevron), Roles.RChevron);
}
/// <summary>
/// Return a header node form of a specified standard node
/// </summary>
/// <param name="node"></param>
/// <param name="headerNode"></param>
public static void GetHeaderNode(AstNode node, AstNode headerNode)
{
if (node is ConstructorDeclaration)
{
var _node = node as ConstructorDeclaration;
var _header = headerNode as HeaderConstructorDeclaration;
foreach (var token in _node.ModifierTokens)
headerNode.AddChild((CppModifierToken)token.Clone(), HeaderConstructorDeclaration.ModifierRole);
foreach (var att in _node.Attributes)
headerNode.AddChild((AttributeSection)att.Clone(), HeaderConstructorDeclaration.AttributeRole);
foreach (var param in _node.Parameters)
headerNode.AddChild((ParameterDeclaration)param.Clone(), HeaderConstructorDeclaration.Roles.Parameter);
_header.Name = _node.Name;
_header.IdentifierToken = new Identifier(_node.Name, TextLocation.Empty);
}
if (node is DestructorDeclaration)
{
var _node = node as DestructorDeclaration;
var _header = headerNode as HeaderDestructorDeclaration;
foreach (var token in _node.ModifierTokens)
headerNode.AddChild((CppModifierToken)token.Clone(), HeaderConstructorDeclaration.ModifierRole);
foreach (var att in _node.Attributes)
headerNode.AddChild((AttributeSection)att.Clone(), HeaderConstructorDeclaration.AttributeRole);
_header.Name = _node.Name;
}
if (node is FieldDeclaration)
{
var _node = node as FieldDeclaration;
var _header = headerNode as HeaderFieldDeclaration;
_header.ReturnType = (AstType)_node.ReturnType.Clone();
foreach (var token in _node.ModifierTokens)
headerNode.AddChild((CppModifierToken)token.Clone(), HeaderConstructorDeclaration.ModifierRole);
foreach (var att in _node.Attributes)
headerNode.AddChild((AttributeSection)att.Clone(), HeaderConstructorDeclaration.AttributeRole);
for (int i = 0; i < _node.Variables.Count; i++)
{
VariableInitializer vi = _node.Variables.ElementAt(i);
_header.Variables.Add(_node.HasModifier(Modifiers.Static) ? new VariableInitializer(vi.Name) : (VariableInitializer)vi.Clone());
}
}
if (node is MethodDeclaration)
{
var _node = node as MethodDeclaration;
var _header = headerNode as HeaderMethodDeclaration;
foreach (var token in _node.ModifierTokens)
headerNode.AddChild((CppModifierToken)token.Clone(), HeaderConstructorDeclaration.ModifierRole);
foreach (var att in _node.Attributes)
headerNode.AddChild((AttributeSection)att.Clone(), HeaderConstructorDeclaration.AttributeRole);
foreach (var param in _node.Parameters)
headerNode.AddChild((ParameterDeclaration)param.Clone(), HeaderConstructorDeclaration.Roles.Parameter);
foreach (var tparam in _node.TypeParameters)
_header.TypeParameters.Add((TypeParameterDeclaration)tparam.Clone());
_header.ReturnType = (AstType)_node.ReturnType.Clone();
_header.PrivateImplementationType = (AstType)_node.PrivateImplementationType.Clone();
_header.TypeMember = (Identifier)_node.TypeMember.Clone();
_header.NameToken = (Identifier)_node.NameToken.Clone();
}
if (node is ConversionConstructorDeclaration)
{
var _node = node as ConversionConstructorDeclaration;
var _header = headerNode as HeaderConversionConstructorDeclaration;
foreach (var token in _node.ModifierTokens)
headerNode.AddChild((CppModifierToken)token.Clone(), HeaderConstructorDeclaration.ModifierRole);
foreach (var att in _node.Attributes)
headerNode.AddChild((AttributeSection)att.Clone(), HeaderConstructorDeclaration.AttributeRole);
_header.ReturnType = (AstType)_node.ReturnType.Clone();
}
if (node is DelegateDeclaration)
{
var _node = node as DelegateDeclaration;
var _header = headerNode as HeaderDelegateDeclaration;
foreach (var token in _node.ModifierTokens)
headerNode.AddChild((CppModifierToken)token.Clone(), HeaderConstructorDeclaration.ModifierRole);
foreach (var att in _node.Attributes)
headerNode.AddChild((AttributeSection)att.Clone(), HeaderConstructorDeclaration.AttributeRole);
foreach (var param in _node.Parameters)
headerNode.AddChild((ParameterDeclaration)param.Clone(), HeaderConstructorDeclaration.Roles.Parameter);
foreach (var tparam in _node.TypeParameters)
_header.TypeParameters.Add((TypeParameterDeclaration)tparam.Clone());
_header.NameToken = (Identifier)_node.NameToken.Clone();
_header.ReturnType = (AstType)_node.ReturnType.Clone();
}
if (node is EventDeclaration)
{
var _node = node as EventDeclaration;
var _header = headerNode as HeaderEventDeclaration;
foreach (var token in _node.ModifierTokens)
headerNode.AddChild((CppModifierToken)token.Clone(), HeaderEventDeclaration.ModifierRole);
foreach (var att in _node.Attributes)
headerNode.AddChild((AttributeSection)att.Clone(), HeaderEventDeclaration.AttributeRole);
foreach (var variable in _node.Variables)
headerNode.AddChild((VariableInitializer)variable.Clone(), HeaderEventDeclaration.Roles.Variable);
_header.ReturnType = (AstType)_node.ReturnType.Clone();
}
else
headerNode = null;
}
public void AddAttributeSection(AstNode parent, Attributes attrs, Role<AttributeSection> role)
{
if (attrs == null)
return;
foreach (var attr in attrs.Sections) {
var section = ConvertAttributeSection(attr);
if (section == null)
continue;
parent.AddChild(section, role);
}
}
static void ConvertCustomAttributes(AstNode attributedNode, ICustomAttributeProvider customAttributeProvider, string attributeTarget = null)
{
if (customAttributeProvider.HasCustomAttributes) {
var attributes = new List<ICSharpCode.NRefactory.CSharp.Attribute>();
foreach (var customAttribute in customAttributeProvider.CustomAttributes) {
if (customAttribute.AttributeType.Name == "ExtensionAttribute" && customAttribute.AttributeType.Namespace == "System.Runtime.CompilerServices") {
// don't show the ExtensionAttribute (it's converted to the 'this' modifier)
continue;
}
if (customAttribute.AttributeType.Name == "ParamArrayAttribute" && customAttribute.AttributeType.Namespace == "System") {
// don't show the ParamArrayAttribute (it's converted to the 'params' modifier)
continue;
}
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 (attributeTarget == "module" || attributeTarget == "assembly") {
// use separate section for each attribute
foreach (var attribute in attributes) {
var section = new AttributeSection();
section.AttributeTarget = attributeTarget;
section.Attributes.Add(attribute);
attributedNode.AddChild(section, AttributedNode.AttributeRole);
}
} else if (attributes.Count > 0) {
// use single section for all attributes
var section = new AttributeSection();
section.AttributeTarget = attributeTarget;
section.Attributes.AddRange(attributes);
attributedNode.AddChild(section, AttributedNode.AttributeRole);
}
}
}
