public bool ContainsLaterAssignments(VariableInitializer variableInitializer)
{
_foundInvocations = false;
_variableInitializer = variableInitializer;
variableInitializer.Parent.Parent.AcceptVisitor(this);
return(_foundInvocations);
}
protected void EmitEventAccessor(EventDeclaration e, VariableInitializer evtVar, bool add)
{
string name = evtVar.Name;
this.Write(add ? "add" : "remove", name, " : ");
this.WriteFunction();
this.WriteOpenParentheses();
this.Write("value");
this.WriteCloseParentheses();
this.WriteSpace();
this.BeginBlock();
this.WriteThis();
this.WriteDot();
this.Write(this.Emitter.GetEntityName(e));
this.Write(" = ");
this.Write(Bridge.Translator.Emitter.ROOT, ".", add ? Bridge.Translator.Emitter.DELEGATE_COMBINE : Bridge.Translator.Emitter.DELEGATE_REMOVE);
this.WriteOpenParentheses();
this.WriteThis();
this.WriteDot();
this.Write(this.Emitter.GetEntityName(e));
this.WriteComma();
this.WriteSpace();
this.Write("value");
this.WriteCloseParentheses();
this.WriteSemiColon();
this.WriteNewLine();
this.EndBlock();
}
string ParseVariableInitializer(VariableInitializer v, string returntype)
{
var varname = v.Name;
if (returntype != null)
{
Append(varname + ":" + returntype);
}
else
{
Append(varname);
}
if (v.Initializer != null)
{
Append("=");
var rtype = ParseExpression(v.Initializer, null);
if (rtype == null)
{
throw new Exception("rtype can not be null.");
}
if (rtype != "any" && rtype != "number" && rtype != "bool" && ((v.Initializer is ObjectCreateExpression) == false) && proj.types[rtype].classtype == "struct")
{
Append(".Clone()");
}
return(rtype);
}
return(null);
}
protected void EmitEventAccessor(EventDeclaration e, VariableInitializer evtVar, bool add)
{
string name = evtVar.Name;
this.Write(add ? "add" : "remove", name, " : ");
this.WriteFunction();
this.WriteOpenParentheses();
this.Write("value");
this.WriteCloseParentheses();
this.WriteSpace();
this.BeginBlock();
this.WriteThis();
this.WriteDot();
this.Write(this.Emitter.GetEntityName(e));
this.Write(" = ");
this.Write(Bridge.Translator.Emitter.ROOT, ".", add ? Bridge.Translator.Emitter.DELEGATE_COMBINE : Bridge.Translator.Emitter.DELEGATE_REMOVE);
this.WriteOpenParentheses();
this.WriteThis();
this.WriteDot();
this.Write(this.Emitter.GetEntityName(e));
this.WriteComma();
this.WriteSpace();
this.Write("value");
this.WriteCloseParentheses();
this.WriteSemiColon();
this.WriteNewLine();
this.EndBlock();
}
bool CanBeSimplified(VariableDeclarationStatement varDecl)
{
if (FixUtil.Instance.NeedFix("SimplyLocalVariableDeclarationsUsingVar.CanBeSimplified"))
{
string strParameter = string.Format("SimplyLocalVariableDeclarationsUsingVar,CanBeSimplified,{0},{1}", typeof(object), typeof(VariableDeclarationStatement));
FixUtil.Instance.Fix(strParameter, this, varDecl);
return;
}
if (varDecl.Variables.Count != 1)
{
return(false);
}
if (varDecl.Modifiers != Modifiers.None) // this line was "forgotten" in the article
{
return(false);
}
VariableInitializer v = varDecl.Variables.Single();
ObjectCreateExpression oce = v.Initializer as ObjectCreateExpression;
if (oce == null)
{
return(false);
}
//return ?AreEqualTypes?(varDecl.Type, oce.Type);
return(varDecl.Type.IsMatch(oce.Type));
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
base.VisitVariableInitializer(variableInitializer);
IType leftType = null;
var result = Resolver.Resolve(variableInitializer);
if (result.IsError)
{
Trace.WriteLine("Error resolving: " + variableInitializer);
return;
}
var memberResult = result as MemberResolveResult;
if (memberResult != null)
{
leftType = memberResult.Member.ReturnType;
}
else
{
var localResult = result as LocalResolveResult;
if (localResult != null)
{
leftType = localResult.Variable.Type;
}
else
{
Debugger.Break();
}
}
var initializerResolve = Resolver.Resolve(variableInitializer.Initializer);
CreateSubtypeRelation(variableInitializer, initializerResolve.Type, leftType, SubtypeKind.VariableInitializer, variableInitializer.Initializer is ThisReferenceExpression);
}
public void Run(RefactoringContext context)
{
var property = context.GetNode <PropertyDeclaration> ();
string backingStoreName = context.GetNameProposal(property.Name);
// create field
var backingStore = new FieldDeclaration();
backingStore.ReturnType = property.ReturnType.Clone();
var initializer = new VariableInitializer(backingStoreName);
backingStore.Variables.Add(initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone();
var id1 = new IdentifierExpression(backingStoreName);
var id2 = new IdentifierExpression(backingStoreName);
newProperty.Getter.Body = new BlockStatement()
{
new ReturnStatement(id1)
};
newProperty.Setter.Body = new BlockStatement()
{
new ExpressionStatement(new AssignmentExpression(id2, AssignmentOperatorType.Assign, new IdentifierExpression("value")))
};
using (var script = context.StartScript()) {
script.Replace(property, newProperty);
script.InsertBefore(property, backingStore);
script.Link(initializer, id1, id2);
}
}
protected void EmitEventAccessor(EventDeclaration e, VariableInitializer evtVar, bool add)
{
string name = evtVar.Name;
this.Write(Helpers.GetAddOrRemove(add), name, " : ");
this.WriteFunction();
this.WriteOpenParentheses();
this.Write("value");
this.WriteCloseParentheses();
this.WriteSpace();
this.BeginBlock();
this.WriteThis();
this.WriteDot();
this.Write(this.Emitter.GetEntityName(e));
this.Write(" = ");
this.Write(add ? JS.Funcs.BRIDGE_COMBINE : JS.Funcs.BRIDGE_REMOVE);
this.WriteOpenParentheses();
this.WriteThis();
this.WriteDot();
this.Write(this.Emitter.GetEntityName(e));
this.WriteComma();
this.WriteSpace();
this.Write("value");
this.WriteCloseParentheses();
this.WriteSemiColon();
this.WriteNewLine();
this.EndBlock();
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
base.VisitVariableInitializer (variableInitializer);
// check if variable is assigned
if (!variableInitializer.Initializer.IsNull)
return;
var decl = variableInitializer.Parent as VariableDeclarationStatement;
if (decl == null)
return;
var resolveResult = ctx.Resolve (variableInitializer) as LocalResolveResult;
if (resolveResult == null)
return;
if (IsUsed (decl.Parent, resolveResult.Variable, variableInitializer))
return;
AddIssue (variableInitializer.NameToken, ctx.TranslateString ("Remove unused local variable"),
script =>
{
if (decl.Variables.Count == 1) {
script.Remove (decl);
} else {
var newDeclaration = (VariableDeclarationStatement)decl.Clone ();
newDeclaration.Variables.Remove (
newDeclaration.Variables.FirstOrNullObject (v => v.Name == variableInitializer.Name));
script.Replace (decl, newDeclaration);
}
});
}
public virtual void VisitVariableInitializer(VariableInitializer variableInitializer)
{
if (this.ThrowException)
{
throw (System.Exception) this.CreateException(variableInitializer);
}
}
public void Run(AstNode node)
{
Run(node, null);
// Declare all the variables at the end, after all the logic has run.
// This is done so that definite assignment analysis can work on a single representation and doesn't have to be updated
// when we change the AST.
foreach (var v in variablesToDeclare) {
if (v.ReplacedAssignment == null) {
BlockStatement block = (BlockStatement)v.InsertionPoint.Parent;
block.Statements.InsertBefore(
v.InsertionPoint,
new VariableDeclarationStatement((AstType)v.Type.Clone(), v.Name));
}
}
// First do all the insertions, then do all the replacements. This is necessary because a replacement might remove our reference point from the AST.
foreach (var v in variablesToDeclare) {
if (v.ReplacedAssignment != null) {
// We clone the right expression so that it doesn't get removed from the old ExpressionStatement,
// which might be still in use by the definite assignment graph.
VariableInitializer initializer = new VariableInitializer(v.Name, v.ReplacedAssignment.Right.Detach()).CopyAnnotationsFrom(v.ReplacedAssignment).WithAnnotation(v.ILVariable);
VariableDeclarationStatement varDecl = new VariableDeclarationStatement {
Type = (AstType)v.Type.Clone(),
Variables = { initializer }
};
ExpressionStatement es = v.ReplacedAssignment.Parent as ExpressionStatement;
if (es != null) {
// Note: if this crashes with 'Cannot replace the root node', check whether two variables were assigned the same name
es.ReplaceWith(varDecl.CopyAnnotationsFrom(es));
} else {
v.ReplacedAssignment.ReplaceWith(varDecl);
}
}
}
variablesToDeclare = null;
}
public JsNode VisitVariableInitializer(VariableInitializer node)
{
var tLocal = node.Annotation <LocalResolveResult>();
if (tLocal != null && tLocal.Type != null && tLocal.Type.Kind == TypeKind.Struct &&
node.ToString() == node.NameToken.ToString() && node.NextSibling.ToString() == ";")
{
var tType = Type.GetType(tLocal.Type.FullName);
//对于基本数据类型，不用new
if (tType == null || !tType.IsPrimitive)
{
var tTypeMember = new JsMemberExpression {
Name = tLocal.Type.FullName
};
var tCtorMember = new JsMemberExpression {
Name = "ctor", PreviousMember = tTypeMember
};
var tInvocation = new JsInvocationExpression {
Member = tCtorMember
};
var tNewObject = new JsNewObjectExpression {
Invocation = tInvocation
};
return(new JsVariableDeclarator
{
Name = node.Name,
Initializer = tNewObject,
});
}
}
return(new JsVariableDeclarator {
Name = node.Name, Initializer = VisitExpression(node.Initializer)
});
}
public override void VisitVariableInitializer (VariableInitializer variableInitializer)
{
base.VisitVariableInitializer (variableInitializer);
var resolveResult = ctx.Resolve (variableInitializer) as LocalResolveResult;
CollectIssues (variableInitializer, variableInitializer.GetParent<BlockStatement> (), resolveResult);
}
public void Run (RefactoringContext context)
{
var property = context.GetNode<PropertyDeclaration> ();
string backingStoreName = context.GetNameProposal (property.Name);
// create field
var backingStore = new FieldDeclaration ();
backingStore.ReturnType = property.ReturnType.Clone ();
var initializer = new VariableInitializer (backingStoreName);
backingStore.Variables.Add (initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone ();
var id1 = new IdentifierExpression (backingStoreName);
var id2 = new IdentifierExpression (backingStoreName);
newProperty.Getter.Body = new BlockStatement () {
new ReturnStatement (id1)
};
newProperty.Setter.Body = new BlockStatement () {
new ExpressionStatement (new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value")))
};
using (var script = context.StartScript ()) {
script.Replace (property, newProperty);
script.InsertBefore (property, backingStore);
script.Link (initializer, id1, id2);
}
}
public virtual void VisitVariableInitializer(VariableInitializer variableInitializer)
{
if (ThrowException)
{
throw (Exception)CreateException(variableInitializer);
}
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
var parentType = variableInitializer.Parent.Parent.GetType();
var isParentClass = variableInitializer.Parent.Parent.GetType().BaseType.Name == "EntityDeclaration";
if (variableInitializer.Parent.Parent.GetType().BaseType.Name == "EntityDeclaration")
{
string accessibility = variableInitializer.Parent.FirstChild.ToString();
var parent = variableInitializer.Parent.Children.GetEnumerator();
parent.MoveNext();
parent.MoveNext();
var type = parent.Current.ToString();;
if (accessibility == "public")
{
properties.Add("+" + variableInitializer.Name + ": " + type);
}
else if (accessibility == "private")
{
properties.Add("-" + variableInitializer.Name + ": " + type);
}
else
{
properties.Add("#" + variableInitializer.Name + ": " + type);
}
}
base.VisitVariableInitializer(variableInitializer);
}
private VariableInitializer convertVariableInicializer(EqualsValueClauseSyntax initializer)
{
var vi = new VariableInitializer();
vi.Expression = convertExpression(initializer.Value);
return(vi);
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
base.VisitVariableInitializer(variableInitializer);
var resolveResult = ctx.Resolve(variableInitializer) as LocalResolveResult;
CollectIssues(variableInitializer, variableInitializer.GetParent <BlockStatement> (), resolveResult);
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
if (!variableInitializer.Initializer.IsNull)
{
HandleAssignmentRHS(variableInitializer.Initializer);
}
base.VisitVariableInitializer(variableInitializer);
}
protected static T WithVariableInitializer <T>(VariableInitializer variable, Func <Expression, T> valueGetter, T defaultValue)
{
if (variable == null || variable.Initializer == null || variable.Initializer.GetText() == "null")
{
return(defaultValue);
}
return(valueGetter(variable.Initializer));
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
base.VisitVariableInitializer(variableInitializer);
var resolveResult = ctx.Resolve(variableInitializer) as LocalResolveResult;
CollectIssues(variableInitializer, variableInitializer.Parent.Parent, resolveResult);
}
private void handleVariableInitializer(VariableInitializer variable)
{
if (variable.Parent.GetType() == typeof(FieldDeclaration))
{
var field = (FieldDeclaration)variable.Parent;
var returnType = signatureFrom(field.ReturnType);
_writer.WriteField(
addMemberInfo(
new Field(
_file,
getMemberNamespace(),
variable.Name,
getTypeModifier(field.Modifiers),
variable.NameToken.StartLocation.Line,
variable.NameToken.StartLocation.Column,
returnType)
.SetEndPosition(
variable.EndLocation.Line,
variable.EndLocation.Column),
field));
return;
}
if (!_getLocalVariables)
{
return;
}
var type = "";
if (variable.Parent.GetType() == typeof(VariableDeclarationStatement))
{
var varDecl = (VariableDeclarationStatement)variable.Parent;
type = signatureFrom(varDecl.Type);
if (type == "var")
{
type = signatureFrom(variable);
}
}
else
{
type = variable.Parent.GetType().ToString();
}
_writer.WriteVariable(
new Variable(
_file,
_containingMethod,
variable.Name,
"local",
variable.NameToken.StartLocation.Line,
variable.NameToken.StartLocation.Column,
type)
.SetEndPosition(
variable.EndLocation.Line,
variable.EndLocation.Column));
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
base.VisitVariableInitializer(variableInitializer);
if (!variableInitializer.Initializer.IsNull)
{
var variableType = ctx.Resolve(variableInitializer).Type;
CheckConversion(variableType, variableInitializer.Initializer);
}
}
public bool ContainsRefOrOut(VariableInitializer variableInitializer)
{
var node = variableInitializer.Parent.Parent;
foundInvocations = false;
_varName = variableInitializer.Name;
node.AcceptVisitor(this);
return(foundInvocations);
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
if (startLocation.IsEmpty || startLocation <= variableInitializer.StartLocation && variableInitializer.EndLocation <= endLocation)
{
SetState(variableInitializer.Name, variableInitializer.Initializer.IsNull ? VariableState.None : VariableState.Changed);
}
base.VisitVariableInitializer(variableInitializer);
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode <PropertyDeclaration>();
if (property == null || !property.NameToken.Contains(context.Location))
{
yield break;
}
if (!(!property.Getter.IsNull && !property.Setter.IsNull && // automatic properties always need getter & setter
property.Getter.Body.IsNull &&
property.Setter.Body.IsNull))
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create backing store"), script => {
string backingStoreName = context.GetNameProposal(property.Name);
// create field
var backingStore = new FieldDeclaration();
if (property.Modifiers.HasFlag(Modifiers.Static))
{
backingStore.Modifiers |= Modifiers.Static;
}
backingStore.ReturnType = property.ReturnType.Clone();
var initializer = new VariableInitializer(backingStoreName);
backingStore.Variables.Add(initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone();
Expression id1;
if (backingStoreName == "value")
{
id1 = new ThisReferenceExpression().Member("value");
}
else
{
id1 = new IdentifierExpression(backingStoreName);
}
Expression id2 = id1.Clone();
newProperty.Getter.Body = new BlockStatement()
{
new ReturnStatement(id1)
};
newProperty.Setter.Body = new BlockStatement()
{
new AssignmentExpression(id2, AssignmentOperatorType.Assign, new IdentifierExpression("value"))
};
script.Replace(property, newProperty);
script.InsertBefore(property, backingStore);
script.Link(initializer, id1, id2);
}, property.NameToken));
}
bool ContainsGetter (PropertyDeclaration property, VariableInitializer initializer)
{
if (property.Getter.IsNull || property.Getter.Body.Statements.Count () != 1)
return false;
var ret = property.Getter.Body.Statements.Single () as ReturnStatement;
if (ret == null)
return false;
return ret.Expression.IsMatch (new IdentifierExpression (initializer.Name)) ||
ret.Expression.IsMatch (new MemberReferenceExpression (new ThisReferenceExpression (), initializer.Name));
}
public override void VisitVariableInitializer (VariableInitializer variableInitializer)
{
base.VisitVariableInitializer (variableInitializer);
if (!(ctx.Resolve (variableInitializer) is LocalResolveResult))
return;
if (HidesMember (ctx, variableInitializer, variableInitializer.Name))
AddIssue (variableInitializer.NameToken,
ctx.TranslateString ("Local variable has the same name as a member and hides it"));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var identifier = context.GetNode <IdentifierExpression>();
if (identifier == null)
{
yield break;
}
if (CreateFieldAction.IsInvocationTarget(identifier))
{
yield break;
}
var statement = context.GetNode <Statement>();
if (statement == null)
{
yield break;
}
if (!(context.Resolve(identifier).IsError))
{
yield break;
}
var guessedType = TypeGuessing.GuessAstType(context, identifier);
if (guessedType == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create local variable"), script => {
var initializer = new VariableInitializer(identifier.Identifier);
var decl = new VariableDeclarationStatement()
{
Type = guessedType,
Variables = { initializer }
};
if (identifier.Parent is AssignmentExpression && ((AssignmentExpression)identifier.Parent).Left == identifier)
{
initializer.Initializer = ((AssignmentExpression)identifier.Parent).Right.Clone();
if (!context.UseExplicitTypes)
{
decl.Type = new SimpleType("var");
}
script.Replace(statement, decl);
}
else
{
script.InsertBefore(statement, decl);
}
}, identifier)
{
Severity = ICSharpCode.NRefactory.Refactoring.Severity.Error
});
}
Expression GetNewCondition(Expression condition, VariableInitializer initializer, bool?direction, Expression step, out Expression newInitializer)
{
var name = initializer.Name;
newInitializer = null;
var bOp = condition as BinaryOperatorExpression;
if (bOp == null || direction == null)
{
return(null);
}
if (direction == true)
{
var upwardPattern = new Choice {
PatternHelper.OptionalParentheses(new BinaryOperatorExpression(PatternHelper.OptionalParentheses(new IdentifierExpression(name)), BinaryOperatorType.LessThan, PatternHelper.OptionalParentheses(new AnyNode("bound")))),
PatternHelper.OptionalParentheses(new BinaryOperatorExpression(PatternHelper.OptionalParentheses(new AnyNode("bound")), BinaryOperatorType.GreaterThan, PatternHelper.OptionalParentheses(new IdentifierExpression(name))))
};
var upMatch = upwardPattern.Match(condition);
if (upMatch.Success)
{
var bound = upMatch.Get <Expression>("bound").FirstOrDefault();
newInitializer = direction == true?Subtract(bound, step) : bound.Clone();
return(GetNewBound(name, false, initializer.Initializer.Clone(), step));
}
var altUpwardPattern = new Choice {
PatternHelper.OptionalParentheses(new BinaryOperatorExpression(PatternHelper.OptionalParentheses(new IdentifierExpression(name)), BinaryOperatorType.LessThanOrEqual, PatternHelper.OptionalParentheses(new AnyNode("bound")))),
PatternHelper.OptionalParentheses(new BinaryOperatorExpression(PatternHelper.OptionalParentheses(new AnyNode("bound")), BinaryOperatorType.GreaterThanOrEqual, PatternHelper.OptionalParentheses(new IdentifierExpression(name))))
};
var altUpMatch = altUpwardPattern.Match(condition);
if (altUpMatch.Success)
{
var bound = altUpMatch.Get <Expression>("bound").FirstOrDefault();
newInitializer = bound.Clone();
return(GetNewBound(name, false, initializer.Initializer.Clone(), step));
}
}
var downPattern = new Choice {
PatternHelper.OptionalParentheses(new BinaryOperatorExpression(PatternHelper.OptionalParentheses(new IdentifierExpression(name)), BinaryOperatorType.GreaterThanOrEqual, PatternHelper.OptionalParentheses(new AnyNode("bound")))),
PatternHelper.OptionalParentheses(new BinaryOperatorExpression(PatternHelper.OptionalParentheses(new AnyNode("bound")), BinaryOperatorType.LessThanOrEqual, PatternHelper.OptionalParentheses(new IdentifierExpression(name))))
};
var downMatch = downPattern.Match(condition);
if (!downMatch.Success)
{
return(null);
}
var bound2 = downMatch.Get <Expression>("bound").FirstOrDefault();
newInitializer = direction == true?Subtract(bound2, step) : bound2.Clone();
return(GetNewBound(name, true, initializer.Initializer.Clone(), step));
}
public override void VisitVariableInitializer(VariableInitializer variableInitializer)
{
var variableDecl = variableInitializer.Parent as VariableDeclarationStatement;
if (variableDecl != null)
{
CheckVariable(((LocalResolveResult)ctx.Resolve(variableInitializer)).Variable,
variableDecl.GetParent <Statement> ());
}
base.VisitVariableInitializer(variableInitializer);
}
/// <summary>
/// Translates a variable initializer, e.g. "x" or "x = 5".
/// </summary>
public override StringBuilder VisitVariableInitializer(VariableInitializer variableInit)
{
var result = new StringBuilder(variableInit.Name);
if (!variableInit.Initializer.IsNull)
{
result.Assign().Append(variableInit.Initializer.AcceptVisitor(this));
}
return(result);
}
public override StringBuilder VisitVariableInitializer(VariableInitializer variableInitializer, int data)
{
var result = new StringBuilder(variableInitializer.Name);
if (!variableInitializer.Initializer.IsNull)
{
result.Append(" = ").Append(variableInitializer.Initializer.AcceptVisitor(this, data));
}
return(result);
}
/// <summary>
/// Retrieves the <see cref="ILVariable"/> associated with this <see cref="VariableInitializer"/>,
/// or <c>null</c> if no variable is associated with this initializer.
/// </summary>
public static ILVariable GetILVariable(this VariableInitializer vi)
{
if (vi.Annotation <ResolveResult>() is ILVariableResolveResult rr)
{
return(rr.Variable);
}
else
{
return(null);
}
}
static EventDeclaration GetEventDeclaration(RefactoringContext context, out VariableInitializer initializer)
{
var result = context.GetNode <EventDeclaration> ();
if (result == null)
{
initializer = null;
return(null);
}
initializer = result.Variables.FirstOrDefault(v => v.NameToken.Contains(context.Location));
return(initializer != null ? result : null);
}
public override object VisitVariableInitializer(VariableInitializer variableInitializer, object data)
{
if (!variableInitializer.AssignToken.IsNull)
{
ForceSpacesAround(variableInitializer.AssignToken, policy.AroundAssignmentParentheses);
}
if (!variableInitializer.Initializer.IsNull)
{
variableInitializer.Initializer.AcceptVisitor(this, data);
}
return(data);
}
public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode<PropertyDeclaration> ();
if (property == null || !property.NameToken.Contains(context.Location))
yield break;
if (!IsNotImplemented (context, property.Getter.Body) ||
!IsNotImplemented (context, property.Setter.Body)) {
yield break;
}
yield return new CodeAction(context.TranslateString("Implement property"), script => {
string backingStoreName = context.GetNameProposal (property.Name);
// create field
var backingStore = new FieldDeclaration ();
if (property.Modifiers.HasFlag (Modifiers.Static))
backingStore.Modifiers |= Modifiers.Static;
if (property.Setter.IsNull)
backingStore.Modifiers |= Modifiers.Readonly;
backingStore.ReturnType = property.ReturnType.Clone ();
var initializer = new VariableInitializer (backingStoreName);
backingStore.Variables.Add (initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone ();
Expression id1;
if (backingStoreName == "value")
id1 = new ThisReferenceExpression().Member("value");
else
id1 = new IdentifierExpression (backingStoreName);
Expression id2 = id1.Clone();
newProperty.Getter.Body = new BlockStatement () {
new ReturnStatement (id1)
};
if (!property.Setter.IsNull) {
newProperty.Setter.Body = new BlockStatement () {
new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value"))
};
}
script.Replace (property, newProperty);
script.InsertBefore (property, backingStore);
if (!property.Setter.IsNull)
script.Link (initializer, id1, id2);
else
script.Link (initializer, id1);
}, property.NameToken);
}
/// <summary>
/// Retrieves the <see cref="ILVariable"/> associated with this <see cref="VariableInitializer"/>, or <c>null</c> if no variable is associated with this initializer.
/// </summary>
public static ILVariable GetILVariable(this VariableInitializer vi)
{
var rr = vi.Annotation <ResolveResult>() as ILVariableResolveResult;
if (rr != null)
{
return(rr.Variable);
}
else
{
return(null);
}
}
public static MethodDeclaration CreateEventInvocator (RefactoringContext context, TypeDeclaration declaringType, EventDeclaration eventDeclaration, VariableInitializer initializer, IMethod invokeMethod, bool useExplictType)
{
bool hasSenderParam = false;
IEnumerable<IParameter> pars = invokeMethod.Parameters;
if (invokeMethod.Parameters.Any()) {
var first = invokeMethod.Parameters [0];
if (first.Name == "sender" /*&& first.Type == "System.Object"*/) {
hasSenderParam = true;
pars = invokeMethod.Parameters.Skip(1);
}
}
const string handlerName = "handler";
var arguments = new List<Expression>();
if (hasSenderParam)
arguments.Add(eventDeclaration.HasModifier (Modifiers.Static) ? (Expression)new PrimitiveExpression (null) : new ThisReferenceExpression());
bool useThisMemberReference = false;
foreach (var par in pars) {
arguments.Add(new IdentifierExpression(par.Name));
useThisMemberReference |= par.Name == initializer.Name;
}
var proposedHandlerName = GetNameProposal(initializer);
var modifiers = eventDeclaration.HasModifier(Modifiers.Static) ? Modifiers.Static : Modifiers.Protected | Modifiers.Virtual;
if (declaringType.HasModifier (Modifiers.Sealed)) {
modifiers = Modifiers.None;
}
var methodDeclaration = new MethodDeclaration {
Name = proposedHandlerName,
ReturnType = new PrimitiveType ("void"),
Modifiers = modifiers,
Body = new BlockStatement {
new VariableDeclarationStatement (
useExplictType ? eventDeclaration.ReturnType.Clone () : new PrimitiveType ("var"), handlerName,
useThisMemberReference ?
(Expression)new MemberReferenceExpression (new ThisReferenceExpression (), initializer.Name)
: new IdentifierExpression (initializer.Name)
),
new IfElseStatement {
Condition = new BinaryOperatorExpression (new IdentifierExpression (handlerName), BinaryOperatorType.InEquality, new PrimitiveExpression (null)),
TrueStatement = new InvocationExpression (new IdentifierExpression (handlerName), arguments)
}
}
};
foreach (var par in pars) {
var typeName = context.CreateShortType(par.Type);
var decl = new ParameterDeclaration(typeName, par.Name);
methodDeclaration.Parameters.Add(decl);
}
return methodDeclaration;
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var pexpr = context.GetNode<PrimitiveExpression>();
if (pexpr == null)
yield break;
var statement = context.GetNode<Statement>();
if (statement == null) {
yield break;
}
var resolveResult = context.Resolve(pexpr);
yield return new CodeAction(context.TranslateString("Create local constant"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
name = service.CheckName(context, name, AffectedEntity.LocalConstant);
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new VariableDeclarationStatement() {
Type = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
script.InsertBefore(statement, decl);
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
script.Link(initializer.NameToken, variableUsage);
});
yield return new CodeAction(context.TranslateString("Create constant field"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
name = service.CheckName(context, name, AffectedEntity.ConstantField);
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new FieldDeclaration() {
ReturnType = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
// script.Link(initializer.NameToken, variableUsage);
script.InsertWithCursor(context.TranslateString("Create constant"), Script.InsertPosition.Before, decl);
});
}
public VariableInitializer ConvertToInitializer(VariableInitializer variableInitializer, ref IList<AstNode> statements)
{
if (variableInitializer == null)
throw new ArgumentNullException("variableInitializer");
if (statements == null)
throw new ArgumentNullException("statements");
Initialize(variableInitializer);
accessPaths [mainAccessPath] = variableInitializer.Initializer.Clone();
Convert(statements);
statements = ReplacementNodeHelper.GetReplacedNodes(accessPaths [mainAccessPath]);
return new VariableInitializer(mainAccessPath.RootName, accessPaths [mainAccessPath]);
}
static CodeAction MoveDeclarationAction(RefactoringContext context, AstNode insertAnchor,
VariableDeclarationStatement declarationStatement, VariableInitializer initializer)
{
var type = declarationStatement.Type.Clone();
var name = initializer.Name;
return new CodeAction(context.TranslateString("Move declaration to outer scope"), script => {
script.InsertBefore(declarationStatement, new ExpressionStatement() {
Expression = new AssignmentExpression(new IdentifierExpression(name), initializer.Initializer.Clone())
});
script.Remove(declarationStatement);
script.InsertBefore(insertAnchor, new VariableDeclarationStatement(type, name, Expression.Null));
});
}
static CodeAction MoveInitializerAction(RefactoringContext context, AstNode insertAnchor,
VariableDeclarationStatement declaration, VariableInitializer initializer)
{
var type = declaration.Type.Clone();
var name = initializer.Name;
return new CodeAction(context.TranslateString("Move initializer to outer scope"), script => {
if (declaration.Variables.Count != 1) {
var innerDeclaration = RemoveInitializer(declaration, initializer);
script.InsertBefore(declaration, innerDeclaration);
}
script.Remove(declaration);
var outerDeclaration = new VariableDeclarationStatement(type, name, initializer.Initializer.Clone());
script.InsertBefore(insertAnchor, outerDeclaration);
});
}
CodeAction HandleInitializer(RefactoringContext context, VariableInitializer initializer)
{
var objectCreateExpression = initializer.Initializer as ObjectCreateExpression;
if (objectCreateExpression == null)
return null;
var initializerRR = context.Resolve(initializer) as LocalResolveResult;
if (initializerRR == null)
return null;
IList<AstNode> statements = GetNodes(context.GetNode<Statement>());
var converter = new StatementsToInitializerConverter(context);
var newInitializer = converter.ConvertToInitializer(initializer, ref statements);
if (statements.Count == 0)
return null;
return MakeAction(context, initializer, newInitializer, statements);
}
public override void VisitVariableInitializer (VariableInitializer variableInitializer)
{
base.VisitVariableInitializer (variableInitializer);
var decl = variableInitializer.Parent as VariableDeclarationStatement;
if (decl == null)
return;
var resolveResult = ctx.Resolve (variableInitializer) as LocalResolveResult;
if (resolveResult == null)
return;
if (!TestOnlyAssigned (ctx, unit, resolveResult.Variable))
return;
AddIssue (variableInitializer.NameToken,
ctx.TranslateString ("Local variable is assigned by its value is never used"));
}
static PropertyDeclaration GeneratePropertyDeclaration (RefactoringContext context, FieldDeclaration field, VariableInitializer initializer)
{
var mod = ICSharpCode.NRefactory.CSharp.Modifiers.Public;
if (field.HasModifier (ICSharpCode.NRefactory.CSharp.Modifiers.Static))
mod |= ICSharpCode.NRefactory.CSharp.Modifiers.Static;
return new PropertyDeclaration () {
Modifiers = mod,
Name = context.GetNameProposal (initializer.Name, false),
ReturnType = field.ReturnType.Clone (),
Getter = new Accessor () {
Body = new BlockStatement () {
new ReturnStatement (new IdentifierExpression (initializer.Name))
}
}
};
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode<PropertyDeclaration>();
if (!(property != null &&
!property.Getter.IsNull && !property.Setter.IsNull && // automatic properties always need getter & setter
property.Getter.Body.IsNull &&
property.Setter.Body.IsNull)) {
yield break;
}
yield return new CodeAction(context.TranslateString("Create backing store"), script => {
string backingStoreName = context.GetNameProposal (property.Name);
// create field
var backingStore = new FieldDeclaration ();
if (property.Modifiers.HasFlag (Modifiers.Static))
backingStore.Modifiers |= Modifiers.Static;
backingStore.ReturnType = property.ReturnType.Clone ();
var initializer = new VariableInitializer (backingStoreName);
backingStore.Variables.Add (initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone ();
Expression id1;
if (backingStoreName == "value")
id1 = new ThisReferenceExpression().Member("value");
else
id1 = new IdentifierExpression (backingStoreName);
Expression id2 = id1.Clone();
newProperty.Getter.Body = new BlockStatement () {
new ReturnStatement (id1)
};
newProperty.Setter.Body = new BlockStatement () {
new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value"))
};
script.Replace (property, newProperty);
script.InsertBefore (property, backingStore);
script.Link (initializer, id1, id2);
});
}
private static List<AstNode> ComputeMatchNodes(RefactoringContext context, VariableInitializer firstOrNullObject)
{
var referenceFinder = new FindReferences();
var matchedNodes = new List<AstNode>();
var resolveResult = context.Resolver.Resolve(firstOrNullObject);
var member = resolveResult as MemberResolveResult;
if (member == null)//not a member is unexpected case, so is better to return no match than to break the code
return matchedNodes;
FoundReferenceCallback callback = (matchNode, result) => matchedNodes.Add(matchNode);
var searchScopes = referenceFinder.GetSearchScopes(member.Member);
referenceFinder.FindReferencesInFile(searchScopes,
context.UnresolvedFile,
context.RootNode as SyntaxTree,
context.Compilation, callback,
context.CancellationToken);
return matchedNodes;
}
public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var identifier = context.GetNode<IdentifierExpression>();
if (identifier == null) {
yield break;
}
if (CreateFieldAction.IsInvocationTarget(identifier)) {
yield break;
}
var statement = context.GetNode<Statement>();
if (statement == null) {
yield break;
}
if (!(context.Resolve(identifier).IsError)) {
yield break;
}
var guessedType = CreateFieldAction.GuessAstType(context, identifier);
if (guessedType == null) {
yield break;
}
yield return new CodeAction(context.TranslateString("Create local variable"), script => {
var initializer = new VariableInitializer(identifier.Identifier);
var decl = new VariableDeclarationStatement() {
Type = guessedType,
Variables = { initializer }
};
if (identifier.Parent is AssignmentExpression && ((AssignmentExpression)identifier.Parent).Left == identifier) {
initializer.Initializer = ((AssignmentExpression)identifier.Parent).Right.Clone();
if (!context.UseExplicitTypes)
decl.Type = new SimpleType("var");
script.Replace(statement, decl);
} else {
script.InsertBefore(statement, decl);
}
}, identifier);
}
public void VisitVariableInitializer(VariableInitializer variableInitializer)
{
StartNode(variableInitializer);
variableInitializer.NameToken.AcceptVisitor(this);
if (!variableInitializer.Initializer.IsNull) {
Space(policy.SpaceAroundAssignment);
WriteToken(Roles.Assign);
Space(policy.SpaceAroundAssignment);
variableInitializer.Initializer.AcceptVisitor(this);
}
EndNode(variableInitializer);
}
public override void Visit (Const f)
{
var location = LocationsBag.GetMemberLocation (f);
FieldDeclaration newField = new FieldDeclaration ();
AddModifiers (newField, location);
if (location != null)
newField.AddChild (new CSharpTokenNode (Convert (location[1]), "fixed".Length), FieldDeclaration.Roles.Keyword);
newField.AddChild ((INode)f.TypeName.Accept (this), FieldDeclaration.Roles.ReturnType);
VariableInitializer variable = new VariableInitializer ();
variable.AddChild (new Identifier (f.MemberName.Name, Convert (f.MemberName.Location)), FieldDeclaration.Roles.Identifier);
if (f.Initializer != null) {
if (location != null)
variable.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FieldDeclaration.Roles.Assign);
variable.AddChild ((INode)f.Initializer.Accept (this), FieldDeclaration.Roles.Initializer);
}
newField.AddChild (variable, FieldDeclaration.Roles.Initializer);
if (f.Declarators != null) {
foreach (var decl in f.Declarators) {
var declLoc = LocationsBag.GetLocations (decl);
if (declLoc != null)
newField.AddChild (new CSharpTokenNode (Convert (declLoc[declLoc.Count - 1]), 1), FieldDeclaration.Roles.Comma);
variable = new VariableInitializer ();
variable.AddChild (new Identifier (decl.Name.Value, Convert (decl.Name.Location)), FieldDeclaration.Roles.Identifier);
if (decl.Initializer != null) {
if (declLoc != null)
variable.AddChild (new CSharpTokenNode (Convert (declLoc[0]), 1), FieldDeclaration.Roles.Assign);
variable.AddChild ((INode)decl.Initializer.Accept (this), FieldDeclaration.Roles.Initializer);
}
newField.AddChild (variable, FieldDeclaration.Roles.Initializer);
}
}
if (location != null)
newField.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), 1), FieldDeclaration.Roles.Semicolon);
typeStack.Peek ().AddChild (newField, TypeDeclaration.Roles.Member);
}
public override void Visit (EnumMember em)
{
FieldDeclaration newField = new FieldDeclaration ();
VariableInitializer variable = new VariableInitializer ();
variable.AddChild (new Identifier (em.Name, Convert (em.Location)), AbstractNode.Roles.Identifier);
if (em.Initializer != null) {
INode initializer = (INode)Visit (em.Initializer);
if (initializer != null)
variable.AddChild (initializer, AbstractNode.Roles.Initializer);
}
newField.AddChild (variable, AbstractNode.Roles.Initializer);
typeStack.Peek ().AddChild (newField, TypeDeclaration.Roles.Member);
}
VariableDeclarationStatement CreateVariableDeclaration (LocalInfo info)
{
VariableDeclarationStatement result = new VariableDeclarationStatement ();
result.AddChild ((INode)info.Type.Accept (this), CatchClause.Roles.ReturnType);
VariableInitializer variable = new VariableInitializer ();
variable.AddChild (new Identifier (info.Name, Convert (info.Location)), AbstractNode.Roles.Identifier);
result.AddChild (variable, AbstractNode.Roles.Initializer);
result.AddChild (new Identifier (info.Name, Convert (info.Location)), CatchClause.Roles.ReturnType);
return result;
}
public void VisitVariableInitializer(VariableInitializer initializer)
{
UniqueIdGenerator.DefineNewId(initializer.NameToken);
initializer.Initializer.AcceptWalker(this);
}
public virtual void VisitVariableInitializer (VariableInitializer variableInitializer)
{
VisitChildren (variableInitializer);
}
public override void Visit(Const c)
{
var location = LocationsBag.GetMemberLocation(c);
var newField = new FieldDeclaration();
AddAttributeSection(newField, c);
AddModifiers(newField, location);
if (location != null)
newField.AddChild(new CSharpModifierToken(Convert(location [0]), Modifiers.Const), EntityDeclaration.ModifierRole);
newField.AddChild(ConvertToType(c.TypeExpression), Roles.Type);
var variable = new VariableInitializer();
variable.AddChild(Identifier.Create(c.MemberName.Name, Convert(c.MemberName.Location)), Roles.Identifier);
if (c.Initializer != null) {
variable.AddChild(new CSharpTokenNode(Convert(c.Initializer.Location), Roles.Assign), Roles.Assign);
variable.AddChild((Expression)c.Initializer.Accept(this), Roles.Expression);
}
newField.AddChild(variable, Roles.Variable);
if (c.Declarators != null) {
foreach (var decl in c.Declarators) {
var declLoc = LocationsBag.GetLocations(decl);
if (declLoc != null)
newField.AddChild(new CSharpTokenNode(Convert(declLoc [0]), Roles.Comma), Roles.Comma);
variable = new VariableInitializer();
variable.AddChild(Identifier.Create(decl.Name.Value, Convert(decl.Name.Location)), Roles.Identifier);
if (decl.Initializer != null) {
variable.AddChild(new CSharpTokenNode(Convert(decl.Initializer.Location), Roles.Assign), Roles.Assign);
variable.AddChild((Expression)decl.Initializer.Accept(this), Roles.Expression);
}
newField.AddChild(variable, Roles.Variable);
}
}
if (location != null)
newField.AddChild(new CSharpTokenNode(Convert(location [1]), Roles.Semicolon), Roles.Semicolon);
typeStack.Peek().AddChild(newField, Roles.TypeMemberRole);
}
public override void Visit(Field f)
{
var location = LocationsBag.GetMemberLocation(f);
var newField = new FieldDeclaration();
AddAttributeSection(newField, f);
AddModifiers(newField, location);
newField.AddChild(ConvertToType(f.TypeExpression), Roles.Type);
var variable = new VariableInitializer();
variable.AddChild(Identifier.Create(f.MemberName.Name, Convert(f.MemberName.Location)), Roles.Identifier);
int locationIdx = 0;
if (f.Initializer != null) {
if (location != null)
variable.AddChild(new CSharpTokenNode(Convert(location [locationIdx++]), Roles.Assign), Roles.Assign);
variable.AddChild((Expression)f.Initializer.Accept(this), Roles.Expression);
}
newField.AddChild(variable, Roles.Variable);
if (f.Declarators != null) {
foreach (var decl in f.Declarators) {
var declLoc = LocationsBag.GetLocations(decl);
if (declLoc != null)
newField.AddChild(new CSharpTokenNode(Convert(declLoc [0]), Roles.Comma), Roles.Comma);
variable = new VariableInitializer();
variable.AddChild(Identifier.Create(decl.Name.Value, Convert(decl.Name.Location)), Roles.Identifier);
if (decl.Initializer != null) {
if (declLoc != null)
variable.AddChild(new CSharpTokenNode(Convert(declLoc [1]), Roles.Assign), Roles.Assign);
variable.AddChild((Expression)decl.Initializer.Accept(this), Roles.Expression);
}
newField.AddChild(variable, Roles.Variable);
}
}
if (location != null && location.Count > locationIdx)
newField.AddChild(new CSharpTokenNode(Convert(location [locationIdx++]), Roles.Semicolon), Roles.Semicolon);
typeStack.Peek().AddChild(newField, Roles.TypeMemberRole);
}
public override object Visit(Fixed fixedStatement)
{
var result = new FixedStatement();
var location = LocationsBag.GetLocations(fixedStatement);
result.AddChild(new CSharpTokenNode(Convert(fixedStatement.loc), FixedStatement.FixedKeywordRole), FixedStatement.FixedKeywordRole);
if (location != null)
result.AddChild(new CSharpTokenNode(Convert(location [0]), Roles.LPar), Roles.LPar);
if (fixedStatement.Variables != null) {
var blockVariableDeclaration = fixedStatement.Variables;
result.AddChild(ConvertToType(blockVariableDeclaration.TypeExpression), Roles.Type);
var varInit = new VariableInitializer();
var initLocation = LocationsBag.GetLocations(blockVariableDeclaration);
varInit.AddChild(Identifier.Create(blockVariableDeclaration.Variable.Name, Convert(blockVariableDeclaration.Variable.Location)), Roles.Identifier);
if (blockVariableDeclaration.Initializer != null) {
if (initLocation != null)
varInit.AddChild(new CSharpTokenNode(Convert(initLocation [0]), Roles.Assign), Roles.Assign);
varInit.AddChild((Expression)blockVariableDeclaration.Initializer.Accept(this), Roles.Expression);
}
result.AddChild(varInit, Roles.Variable);
if (blockVariableDeclaration.Declarators != null) {
foreach (var decl in blockVariableDeclaration.Declarators) {
var loc = LocationsBag.GetLocations(decl);
var init = new VariableInitializer();
if (loc != null && loc.Count > 0)
result.AddChild(new CSharpTokenNode(Convert(loc [0]), Roles.Comma), Roles.Comma);
init.AddChild(Identifier.Create(decl.Variable.Name, Convert(decl.Variable.Location)), Roles.Identifier);
if (decl.Initializer != null) {
if (loc != null && loc.Count > 1)
init.AddChild(new CSharpTokenNode(Convert(loc [1]), Roles.Assign), Roles.Assign);
init.AddChild((Expression)decl.Initializer.Accept(this), Roles.Expression);
}
result.AddChild(init, Roles.Variable);
}
}
}
if (location != null && location.Count > 1)
result.AddChild(new CSharpTokenNode(Convert(location [1]), Roles.RPar), Roles.RPar);
if (fixedStatement.Statement != null)
result.AddChild((Statement)fixedStatement.Statement.Accept(this), Roles.EmbeddedStatement);
return result;
}
public UsingStatement CreateUsingStatement(Block blockStatement)
{
var usingResult = new UsingStatement();
Mono.CSharp.Statement cur = blockStatement.Statements [0];
var u = cur as Using;
if (u != null) {
usingResult.AddChild(new CSharpTokenNode(Convert(u.loc), UsingStatement.UsingKeywordRole), UsingStatement.UsingKeywordRole);
usingResult.AddChild(new CSharpTokenNode(Convert(blockStatement.StartLocation), Roles.LPar), Roles.LPar);
if (u.Variables != null) {
var initializer = new VariableInitializer {
NameToken = Identifier.Create(u.Variables.Variable.Name, Convert(u.Variables.Variable.Location)),
};
var loc = LocationsBag.GetLocations(u.Variables);
if (loc != null)
initializer.AddChild(new CSharpTokenNode(Convert(loc [0]), Roles.Assign), Roles.Assign);
if (u.Variables.Initializer != null)
initializer.Initializer = u.Variables.Initializer.Accept(this) as Expression;
var varDec = new VariableDeclarationStatement {
Type = ConvertToType(u.Variables.TypeExpression),
Variables = { initializer }
};
if (u.Variables.Declarators != null) {
foreach (var decl in u.Variables.Declarators) {
var declLoc = LocationsBag.GetLocations(decl);
var init = new VariableInitializer();
if (declLoc != null && declLoc.Count > 0)
varDec.AddChild(new CSharpTokenNode(Convert(declLoc [0]), Roles.Comma), Roles.Comma);
init.AddChild(Identifier.Create(decl.Variable.Name, Convert(decl.Variable.Location)), Roles.Identifier);
if (decl.Initializer != null) {
if (declLoc != null && declLoc.Count > 1)
init.AddChild(new CSharpTokenNode(Convert(declLoc [1]), Roles.Assign), Roles.Assign);
init.AddChild((Expression)decl.Initializer.Accept(this), Roles.Expression);
}
varDec.AddChild(init, Roles.Variable);
}
}
usingResult.AddChild(varDec, UsingStatement.ResourceAcquisitionRole);
}
cur = u.Statement;
usingResult.AddChild(new CSharpTokenNode(Convert(blockStatement.EndLocation), Roles.RPar), Roles.RPar);
if (cur != null)
usingResult.AddChild((Statement)cur.Accept(this), Roles.EmbeddedStatement);
}
return usingResult;
}
public override object Visit(BlockConstant blockConstantDeclaration)
{
var result = new VariableDeclarationStatement();
var location = LocationsBag.GetLocations(blockConstantDeclaration);
if (location != null && location.Count > 0)
result.AddChild(new CSharpModifierToken(Convert(location [0]), Modifiers.Const), VariableDeclarationStatement.ModifierRole);
result.AddChild(ConvertToType(blockConstantDeclaration.TypeExpression), Roles.Type);
var varInit = new VariableInitializer();
varInit.AddChild(Identifier.Create(blockConstantDeclaration.Variable.Name, Convert(blockConstantDeclaration.Variable.Location)), Roles.Identifier);
if (blockConstantDeclaration.Initializer != null) {
if (location != null && location.Count > 1)
varInit.AddChild(new CSharpTokenNode(Convert(location [1]), Roles.Assign), Roles.Assign);
varInit.AddChild((Expression)blockConstantDeclaration.Initializer.Accept(this), Roles.Expression);
}
result.AddChild(varInit, Roles.Variable);
if (blockConstantDeclaration.Declarators != null) {
foreach (var decl in blockConstantDeclaration.Declarators) {
var loc = LocationsBag.GetLocations(decl);
var init = new VariableInitializer();
init.AddChild(Identifier.Create(decl.Variable.Name, Convert(decl.Variable.Location)), Roles.Identifier);
if (decl.Initializer != null) {
if (loc != null)
init.AddChild(new CSharpTokenNode(Convert(loc [0]), Roles.Assign), Roles.Assign);
init.AddChild((Expression)decl.Initializer.Accept(this), Roles.Expression);
if (loc != null && loc.Count > 1)
result.AddChild(new CSharpTokenNode(Convert(loc [1]), Roles.Comma), Roles.Comma);
} else {
if (loc != null && loc.Count > 0)
result.AddChild(new CSharpTokenNode(Convert(loc [0]), Roles.Comma), Roles.Comma);
}
result.AddChild(init, Roles.Variable);
}
}
if (location != null) {
result.AddChild(new CSharpTokenNode(Convert(location [location.Count - 1]), Roles.Semicolon), Roles.Semicolon);
} else {
// parser error, set end node to max value.
result.AddChild(new ErrorNode(), Roles.Error);
}
return result;
}
