public void Run (RefactoringContext context)
{
var foreachStatement = GetForeachStatement (context);
var result = context.ResolveType (foreachStatement.InExpression);
var countProperty = GetCountProperty (result);
var initializer = new VariableDeclarationStatement (new PrimitiveType ("int"), "i", new PrimitiveExpression (0));
var id1 = new IdentifierExpression ("i");
var id2 = id1.Clone ();
var id3 = id1.Clone ();
var forStatement = new ForStatement () {
Initializers = { initializer },
Condition = new BinaryOperatorExpression (id1, BinaryOperatorType.LessThan, new MemberReferenceExpression (foreachStatement.InExpression.Clone (), countProperty)),
Iterators = { new ExpressionStatement (new UnaryOperatorExpression (UnaryOperatorType.PostIncrement, id2)) },
EmbeddedStatement = new BlockStatement {
new VariableDeclarationStatement (foreachStatement.VariableType.Clone (), foreachStatement.VariableName, new IndexerExpression (foreachStatement.InExpression.Clone (), id3))
}
};
if (foreachStatement.EmbeddedStatement is BlockStatement) {
foreach (var child in ((BlockStatement)foreachStatement.EmbeddedStatement).Statements) {
forStatement.EmbeddedStatement.AddChild (child.Clone (), BlockStatement.StatementRole);
}
} else {
forStatement.EmbeddedStatement.AddChild (foreachStatement.EmbeddedStatement.Clone (), BlockStatement.StatementRole);
}
using (var script = context.StartScript ()) {
script.Replace (foreachStatement, forStatement);
script.Link (initializer.Variables.First ().NameToken, id1, id2, id3);
}
}
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.
VariableDeclarationStatement varDecl = new VariableDeclarationStatement {
Type = (AstType)v.Type.Clone(),
Variables = { new VariableInitializer(v.Name, v.ReplacedAssignment.Right.Detach()).CopyAnnotationsFrom(v.ReplacedAssignment) }
};
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 override void VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement) {
foreach (var varNode in variableDeclarationStatement.Variables) {
AddVariable(varNode, varNode.Name);
}
base.VisitVariableDeclarationStatement(variableDeclarationStatement);
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
Guard.AgainstNullArgument("methodDeclaration", methodDeclaration);
IEnumerable<ParameterDeclaration> parameters = methodDeclaration
.GetChildrenByRole(Roles.Parameter)
.Select(x => (ParameterDeclaration)x.Clone());
var isVoid = false;
var isAsync = methodDeclaration.Modifiers.HasFlag(Modifiers.Async);
AstType returnType = methodDeclaration.GetChildByRole(Roles.Type).Clone();
var type = returnType as PrimitiveType;
if (type != null)
{
isVoid = string.Compare(
type.Keyword, "void", StringComparison.OrdinalIgnoreCase) == 0;
}
var methodType = new SimpleType(Identifier.Create(isVoid ? "Action" : "Func"));
IEnumerable<AstType> types = parameters.Select(
x => x.GetChildByRole(Roles.Type).Clone());
methodType
.TypeArguments
.AddRange(types);
if (!isVoid)
{
methodType.TypeArguments.Add(returnType);
}
var methodName = GetIdentifierName(methodDeclaration);
var methodBody = methodDeclaration
.GetChildrenByRole(Roles.Body)
.FirstOrDefault();
if (methodBody == null)
{
throw new NullReferenceException(string.Format("Method '{0}' has no method body", methodName));
}
methodBody = (BlockStatement)methodBody.Clone();
var prototype = new VariableDeclarationStatement { Type = methodType };
prototype.Variables.Add(new VariableInitializer(methodName));
var anonymousMethod = new AnonymousMethodExpression(methodBody, parameters) { IsAsync = isAsync };
var expression = new ExpressionStatement
{
Expression = new AssignmentExpression(
new IdentifierExpression(methodName),
anonymousMethod)
};
_methods.Add(new MethodVisitorResult
{
MethodDefinition = methodDeclaration,
MethodPrototype = prototype,
MethodExpression = expression
});
}
void HandleVisitorVariableDeclarationStatementVisited (VariableDeclarationStatement node, InspectionData data)
{
foreach (var rule in policy.Rules) {
if (rule.CheckVariableDeclaration (node, data))
return;
}
}
public override void VisitVariableDeclarationStatement(VariableDeclarationStatement varDecl)
{
// if (CanBeSimplified(varDecl)) {
// varDecl.Type = new SimpleType("var");
// }
// recurse into the statement (there might be a lambda with additional variable declaration statements inside there)
base.VisitVariableDeclarationStatement(varDecl);
}
public override object VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
{
if ((variableDeclarationStatement.Modifiers & Modifiers.Const) == Modifiers.Const)
{
UnlockWith(variableDeclarationStatement);
}
return base.VisitVariableDeclarationStatement(variableDeclarationStatement, data);
}
public override object VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
{
var anonInitializer = variableDeclarationStatement.Variables.FirstOrDefault(a => a.Initializer is AnonymousTypeCreateExpression);
if (anonInitializer != null)
{
UnlockWith(anonInitializer.Initializer);
}
return base.VisitVariableDeclarationStatement(variableDeclarationStatement, data);
}
public override void Visit(VariableDeclarationStatement expression)
{
if (expression.Expression != null)
{
outStream.Write("var {0} = {1}(", expression.Identifier, printFuncName);
expression.Expression.Accept(this);
outStream.Write(", \"{0}\")", TempName);
}
else
outStream.Write("var {0}", expression.Identifier);
}
static VariableInitializer GetControlVariable(VariableDeclarationStatement variableDecl,
UnaryOperatorExpression condition)
{
var controlVariables = variableDecl.Variables.Where (
v =>
{
var identifier = new IdentifierExpression (v.Name);
return condition.Expression.Match (identifier).Success;
}).ToList ();
return controlVariables.Count == 1 ? controlVariables [0] : null;
}
void HandleVisitiorVariableDeclarationStatementVisited (VariableDeclarationStatement node, InspectionData data)
{
if (node.Type is PrimitiveType)
return;
if (node.Type is SimpleType && ((SimpleType)node.Type).Identifier == "var")
return;
var severity = base.node.GetSeverity ();
if (severity == MonoDevelop.SourceEditor.QuickTaskSeverity.None)
return;
//only checks for cases where the type would be obvious - assignment of new, cast, etc.
//also check the type actually matches else the user might want to assign different subclasses later
foreach (var v in node.Variables) {
if (v.Initializer.IsNull)
return;
var arrCreate = v.Initializer as ArrayCreateExpression;
if (arrCreate != null) {
var n = node.Type as ComposedType;
//FIXME: check the specifier compatibility
if (n != null && n.ArraySpecifiers.Any () && n.BaseType.IsMatch (arrCreate.Type))
continue;
return;
}
var objCreate = v.Initializer as ObjectCreateExpression;
if (objCreate != null) {
if (objCreate.Type.IsMatch (node.Type))
continue;
return;
}
var asCast = v.Initializer as AsExpression;
if (asCast != null) {
if (asCast.Type.IsMatch (node.Type))
continue;
return;
}
var cast = v.Initializer as CastExpression;
if (cast != null) {
if (cast.Type.IsMatch (node.Type))
continue;
return;
}
return;
}
data.Add (new Result (
new DomRegion (node.Type.StartLocation.Line, node.Type.StartLocation.Column, node.Type.EndLocation.Line, node.Type.EndLocation.Column),
GettextCatalog.GetString ("Use implicitly typed local variable decaration"),
severity,
ResultCertainty.High,
ResultImportance.Medium,
severity != MonoDevelop.SourceEditor.QuickTaskSeverity.Suggestion)
);
}
public override void VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
{
base.VisitVariableDeclarationStatement(variableDeclarationStatement);
foreach (var varDecl in variableDeclarationStatement.Variables) {
if (startLocation.IsEmpty || startLocation <= varDecl.StartLocation && varDecl.EndLocation <= endLocation) {
var result = context.Resolve(varDecl);
var local = result as LocalResolveResult;
if (local != null && !UsedVariables.Contains(local.Variable))
UsedVariables.Add(local.Variable);
}
}
}
public override void VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
{
base.VisitVariableDeclarationStatement(variableDeclarationStatement);
if (!(variableDeclarationStatement.Parent is BlockStatement))
// We are somewhere weird, like a the ResourceAquisition of a using statement
return;
if (variableDeclarationStatement.Variables.Count > 1)
return;
// Start at the parent node. Presumably this is a BlockStatement
var rootNode = variableDeclarationStatement.Parent;
var variableInitializer = variableDeclarationStatement.Variables.First();
var identifiers = GetIdentifiers(rootNode.Descendants, variableInitializer.Name).ToList();
if (identifiers.Count == 0)
// variable is not used
return;
AstNode deepestCommonAncestor = GetDeepestCommonAncestor(rootNode, identifiers);
var path = GetPath(rootNode, deepestCommonAncestor);
// Restrict path to only those where the initializer has not changed
var firstInitializerChange = GetFirstInitializerChange(variableDeclarationStatement, path, variableInitializer.Initializer);
if (firstInitializerChange != null) {
path = GetPath(rootNode, firstInitializerChange);
}
// Restict to locations outside of blacklisted node types
var firstBlackListedNode = (from node in path
where moveTargetBlacklist.Contains(node.GetType())
select node).FirstOrDefault();
if (firstBlackListedNode != null) {
path = GetPath(rootNode, firstBlackListedNode);
}
// Get the most nested possible target for the move
Statement mostNestedFollowingStatement = null;
for (int i = path.Count - 1; i >= 0; i--) {
var statement = path[i] as Statement;
if (statement != null && (IsScopeContainer(statement.Parent) || IsScopeContainer(statement))) {
mostNestedFollowingStatement = statement;
break;
}
}
if (mostNestedFollowingStatement != null && mostNestedFollowingStatement != rootNode && mostNestedFollowingStatement.Parent != rootNode) {
AddIssue(variableDeclarationStatement, context.TranslateString("Variable could be moved to a nested scope"),
GetActions(variableDeclarationStatement, mostNestedFollowingStatement));
}
}
bool CanBeSimplified(VariableDeclarationStatement varDecl)
{
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 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);
});
}
protected override IEnumerable<CodeAction> GetFixes(BaseSemanticModel context, Node env,
string variableName)
{
var containingStatement = env.ContainingStatement;
// we don't give a fix for these cases since the general fix may not work
// lambda in while/do-while/for condition
if (containingStatement is WhileStatement || containingStatement is DoWhileStatement ||
containingStatement is ForStatement)
yield break;
// lambda in for initializer/iterator
if (containingStatement.Parent is ForStatement &&
((ForStatement)containingStatement.Parent).EmbeddedStatement != containingStatement)
yield break;
Action<Script> action = script =>
{
var newName = LocalVariableNamePicker.PickSafeName(
containingStatement.GetParent<EntityDeclaration>(),
Enumerable.Range(1, 100).Select(i => variableName + i));
var variableDecl = new VariableDeclarationStatement(new SimpleType("var"), newName,
new IdentifierExpression(variableName));
if (containingStatement.Parent is BlockStatement || containingStatement.Parent is SwitchSection)
{
script.InsertBefore(containingStatement, variableDecl);
}
else
{
var offset = script.GetCurrentOffset(containingStatement.StartLocation);
script.InsertBefore(containingStatement, variableDecl);
script.InsertText(offset, "{");
script.InsertText(script.GetCurrentOffset(containingStatement.EndLocation), "}");
script.FormatText(containingStatement.Parent);
}
var textNodes = new List<AstNode>();
textNodes.Add(variableDecl.Variables.First().NameToken);
foreach (var reference in env.GetAllReferences())
{
var identifier = new IdentifierExpression(newName);
script.Replace(reference.AstNode, identifier);
textNodes.Add(identifier);
}
script.Link(textNodes.ToArray());
};
yield return new CodeAction(context.TranslateString("Copy to local variable"), action, env.AstNode);
}
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);
});
}
/// <summary>
/// Declares a variable in the smallest required scope.
/// </summary>
/// <param name="node">The root of the subtree being searched for the best insertion position</param>
/// <param name="type">The type of the new variable</param>
/// <param name="name">The name of the new variable</param>
/// <param name="allowPassIntoLoops">Whether the variable is allowed to be placed inside a loop</param>
public static VariableDeclarationStatement DeclareVariable(AstNode node, AstType type, string name, bool allowPassIntoLoops = true)
{
VariableDeclarationStatement result = null;
AstNode pos = FindInsertPos(node, name, allowPassIntoLoops);
if (pos != null) {
Match m = assignmentPattern.Match(pos);
if (m != null && m.Get<IdentifierExpression>("ident").Single().Identifier == name) {
result = new VariableDeclarationStatement(type, name, m.Get<Expression>("init").Single().Detach());
pos.ReplaceWith(result);
} else {
result = new VariableDeclarationStatement(type, name);
pos.Parent.InsertChildBefore(pos, result, BlockStatement.StatementRole);
}
}
return result;
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var foreachStatement = GetForeachStatement(context);
if (foreachStatement == null) {
yield break;
}
yield return new CodeAction(context.TranslateString("Convert 'foreach' loop to 'for'"), script => {
var result = context.Resolve(foreachStatement.InExpression);
var countProperty = GetCountProperty(result.Type);
// TODO: use another variable name if 'i' is already in use
var initializer = new VariableDeclarationStatement(new PrimitiveType("int"), "i", new PrimitiveExpression(0));
var id1 = new IdentifierExpression("i");
var id2 = id1.Clone();
var id3 = id1.Clone();
var variableDeclarationStatement = new VariableDeclarationStatement(
foreachStatement.VariableType.Clone(),
foreachStatement.VariableName,
new IndexerExpression(foreachStatement.InExpression.Clone(), id3)
);
var forStatement = new ForStatement() {
Initializers = { initializer },
Condition = new BinaryOperatorExpression (id1, BinaryOperatorType.LessThan, new MemberReferenceExpression (foreachStatement.InExpression.Clone (), countProperty)),
Iterators = { new ExpressionStatement (new UnaryOperatorExpression (UnaryOperatorType.PostIncrement, id2)) },
EmbeddedStatement = new BlockStatement {
variableDeclarationStatement
}
};
if (foreachStatement.EmbeddedStatement is BlockStatement) {
variableDeclarationStatement.Remove();
var oldBlock = (BlockStatement)foreachStatement.EmbeddedStatement.Clone();
if (oldBlock.Statements.Any()) {
oldBlock.Statements.InsertBefore(oldBlock.Statements.First(), variableDeclarationStatement);
} else {
oldBlock.Statements.Add(variableDeclarationStatement);
}
forStatement.EmbeddedStatement = oldBlock;
} else {
forStatement.EmbeddedStatement.AddChild (foreachStatement.EmbeddedStatement.Clone (), BlockStatement.StatementRole);
}
script.Replace (foreachStatement, forStatement);
script.Link (initializer.Variables.First ().NameToken, id1, id2, id3);
});
}
private int curseCount = 0; //This is where it should be
#endregion Fields
#region Methods
public override object VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
{
var foulwords = new[]
{
"f**k", "shit", "crap", "bollocks"
};
foreach (var foulword in foulwords)
{
foreach (var variable in variableDeclarationStatement.Variables)
{
if (Regex.Matches(variable.Name, foulword).Count > 0)
curseCount++;
}
}
if (curseCount > 5)
UnlockWith(variableDeclarationStatement);
return base.VisitVariableDeclarationStatement(variableDeclarationStatement, data);
}
public override object VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
{
var foulwords = new[]
{
"meh","blah", "pft", "rrrr","blib","blab", "blub","lol","uhu","aaah"
};
foreach (var foulword in foulwords)
{
foreach (var variable in variableDeclarationStatement.Variables)
{
if (Regex.Matches(variable.Name, foulword).Count > 0)
_curseCount++;
}
}
if (_curseCount > 5)
UnlockWith(variableDeclarationStatement);
return base.VisitVariableDeclarationStatement(variableDeclarationStatement, data);
}
public override void VisitVariableDeclarationStatement(
VariableDeclarationStatement variableDeclarationStatement)
{
base.VisitVariableDeclarationStatement(variableDeclarationStatement);
if (variableDeclarationStatement.Variables.Count != 1)
return;
var variable = variableDeclarationStatement.Variables.First();
switch (variable.Name)
{
case "__cx":
case "__cy":
case "__cz":
case "__cwidth":
case "__cheight":
case "__cdepth":
this.m_CInitializers[variable.Name] = variable.Initializer;
variableDeclarationStatement.Remove();
break;
}
}
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 override void VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
{
base.VisitVariableDeclarationStatement(variableDeclarationStatement);
if (variableDeclarationStatement.Type is PrimitiveType) {
return;
}
if (variableDeclarationStatement.Type is SimpleType && ((SimpleType)variableDeclarationStatement.Type).Identifier == "var") {
return;
}
if (variableDeclarationStatement.Variables.Count != 1) {
return;
}
//only checks for cases where the type would be obvious - assignment of new, cast, etc.
//also check the type actually matches else the user might want to assign different subclasses later
var v = variableDeclarationStatement.Variables.Single();
var arrCreate = v.Initializer as ArrayCreateExpression;
if (arrCreate != null) {
var n = variableDeclarationStatement.Type as ComposedType;
//FIXME: check the specifier compatibility
if (n != null && n.ArraySpecifiers.Any() && n.BaseType.IsMatch(arrCreate.Type)) {
AddIssue(variableDeclarationStatement);
}
}
var objCreate = v.Initializer as ObjectCreateExpression;
if (objCreate != null && objCreate.Type.IsMatch(variableDeclarationStatement.Type)) {
AddIssue(variableDeclarationStatement);
}
var asCast = v.Initializer as AsExpression;
if (asCast != null && asCast.Type.IsMatch(variableDeclarationStatement.Type)) {
AddIssue(variableDeclarationStatement);
}
var cast = v.Initializer as CastExpression;
if (cast != null && cast.Type.IsMatch(variableDeclarationStatement.Type)) {
AddIssue(variableDeclarationStatement);
}
}
public override object VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
{
foreach(var variable in variableDeclarationStatement.Variables)
{
var objectCreation = variable.Initializer as ObjectCreateExpression;
if(objectCreation != null)
{
var simpleType = objectCreation.Type as SimpleType;
if(simpleType != null && simpleType.Identifier == "Thread")
{
UnlockWith(simpleType);
break;
}
var memberType = objectCreation.Type as MemberType;
var fullNamespace = memberType.GetFullName();
if(fullNamespace == "System.Threading.Thread")
{
UnlockWith(memberType);
}
}
}
return base.VisitVariableDeclarationStatement(variableDeclarationStatement, data);
}
IEnumerable <Syntax> IAstVisitor <ILTranslationContext, IEnumerable <Syntax> > .VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, ILTranslationContext data) => OnVisiting(data, variableDeclarationStatement, VisitingVariableDeclarationStatement) ?? OnVisited(data, variableDeclarationStatement, VisitedVariableDeclarationStatement, TranslateVariableDeclarationStatement(variableDeclarationStatement, data));
//-------------------------------------------------------------------------------------------------------------------------------------------------
public override void VisitVariableDeclaraitonStatement(VariableDeclarationStatement statement)
{
base.VisitVariableDeclaraitonStatement(statement);
AddReferencedType(statement.Variable?.Type);
}
public void NestedArray()
{
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement <VariableDeclarationStatement>("DateTime[,][] a;");
Assert.IsTrue(new VariableDeclarationStatement(new SimpleType("DateTime").MakeArrayType(1).MakeArrayType(2), "a").IsMatch(lvd));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
if (!context.IsSomethingSelected)
{
yield break;
}
var selected = new List <AstNode>(context.GetSelectedNodes());
if (selected.Count != 1 || !(selected [0] is Expression))
{
yield break;
}
var expr = selected [0] as Expression;
var visitor = new SearchNodeVisitior(expr);
var node = context.GetNode <BlockStatement>();
if (node != null)
{
node.AcceptVisitor(visitor);
}
yield return(new CodeAction(context.TranslateString("Declare local variable"), script =>
{
var resolveResult = context.Resolve(expr);
var guessedType = resolveResult.Type;
if (resolveResult is MethodGroupResolveResult)
{
guessedType = GetDelegateType(context, ((MethodGroupResolveResult)resolveResult).Methods.First(), expr);
}
var name = CreateMethodDeclarationAction.CreateBaseName(expr, guessedType);
var type = context.UseExplicitTypes ? context.CreateShortType(guessedType) : new SimpleType("var");
var varDecl = new VariableDeclarationStatement(type, name, expr.Clone());
if (expr.Parent is ExpressionStatement)
{
script.Replace(expr.Parent, varDecl);
script.Select(varDecl.Variables.First().NameToken);
}
else
{
var containing = expr.Parent;
while (!(containing.Parent is BlockStatement))
{
containing = containing.Parent;
}
script.InsertBefore(containing, varDecl);
var identifierExpression = new IdentifierExpression(name);
script.Replace(expr, identifierExpression);
script.Link(varDecl.Variables.First().NameToken, identifierExpression);
}
}));
if (visitor.Matches.Count > 1)
{
yield return(new CodeAction(string.Format(context.TranslateString("Declare local variable (replace '{0}' occurrences)"), visitor.Matches.Count), script =>
{
var resolveResult = context.Resolve(expr);
var guessedType = resolveResult.Type;
if (resolveResult is MethodGroupResolveResult)
{
guessedType = GetDelegateType(context, ((MethodGroupResolveResult)resolveResult).Methods.First(), expr);
}
var linkedNodes = new List <AstNode>();
var name = CreateMethodDeclarationAction.CreateBaseName(expr, guessedType);
var type = context.UseExplicitTypes ? context.CreateShortType(guessedType) : new SimpleType("var");
var varDecl = new VariableDeclarationStatement(type, name, expr.Clone());
linkedNodes.Add(varDecl.Variables.First().NameToken);
var first = visitor.Matches [0];
if (first.Parent is ExpressionStatement)
{
script.Replace(first.Parent, varDecl);
}
else
{
var containing = first.Parent;
while (!(containing.Parent is BlockStatement))
{
containing = containing.Parent;
}
script.InsertBefore(containing, varDecl);
var identifierExpression = new IdentifierExpression(name);
linkedNodes.Add(identifierExpression);
script.Replace(first, identifierExpression);
}
for (int i = 1; i < visitor.Matches.Count; i++)
{
var identifierExpression = new IdentifierExpression(name);
linkedNodes.Add(identifierExpression);
script.Replace(visitor.Matches [i], identifierExpression);
}
script.Link(linkedNodes.ToArray());
}));
}
}
public void ArrayOfNullables()
{
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement <VariableDeclarationStatement>("DateTime?[] a;");
Assert.IsTrue(new VariableDeclarationStatement(new SimpleType("DateTime").MakeNullableType().MakeArrayType(), "a").IsMatch(lvd));
}
public void VoidPointerVariableDeclarationTest()
{
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement <VariableDeclarationStatement>("void *a;");
Assert.IsTrue(new VariableDeclarationStatement(new PrimitiveType("void").MakePointerType(), "a").IsMatch(lvd));
}
public void VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
{
throw new NotImplementedException();
}
public override AstNode VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, ICecilArgumentsResolver argumentsResolver)
{
variableDeclarationStatement.Type.AcceptVisitor(this, argumentsResolver);
return(variableDeclarationStatement);
}
static bool UsesVariable(AstNode node, string variableName)
{
IdentifierExpression ie = node as IdentifierExpression;
if (ie != null && ie.Identifier == variableName)
{
return(true);
}
FixedStatement fixedStatement = node as FixedStatement;
if (fixedStatement != null)
{
foreach (VariableInitializer v in fixedStatement.Variables)
{
if (v.Name == variableName)
{
return(false); // no need to introduce the variable here
}
}
}
ForeachStatement foreachStatement = node as ForeachStatement;
if (foreachStatement != null)
{
if (foreachStatement.VariableName == variableName)
{
return(false); // no need to introduce the variable here
}
}
UsingStatement usingStatement = node as UsingStatement;
if (usingStatement != null)
{
VariableDeclarationStatement varDecl = usingStatement.ResourceAcquisition as VariableDeclarationStatement;
if (varDecl != null)
{
foreach (VariableInitializer v in varDecl.Variables)
{
if (v.Name == variableName)
{
return(false); // no need to introduce the variable here
}
}
}
}
CatchClause catchClause = node as CatchClause;
if (catchClause != null && catchClause.VariableName == variableName)
{
return(false); // no need to introduce the variable here
}
for (AstNode child = node.FirstChild; child != null; child = child.NextSibling)
{
if (UsesVariable(child, variableName))
{
return(true);
}
}
return(false);
}
public void NullableVariableDeclarationStatementTest1()
{
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement <VariableDeclarationStatement>("int? a;");
Assert.IsTrue(new VariableDeclarationStatement(new PrimitiveType("int").MakeNullableType(), "a").IsMatch(lvd));
}
CodeAction CreateFromStatements(RefactoringContext context, List<AstNode> statements)
{
if (!(statements [0].Parent is Statement))
return null;
return new CodeAction(context.TranslateString("Extract method"), script => {
string methodName = "NewMethod";
var method = new MethodDeclaration() {
ReturnType = new PrimitiveType("void"),
Name = methodName,
Body = new BlockStatement()
};
bool usesNonStaticMember = false;
foreach (var node in statements) {
usesNonStaticMember |= StaticVisitor.UsesNotStaticMember(context, node);
if (node is Statement) {
method.Body.Add((Statement)node.Clone());
} else {
method.Body.AddChildUnsafe (node.Clone (), node.Role);
}
}
if (!usesNonStaticMember)
method.Modifiers |= Modifiers.Static;
var target = new IdentifierExpression(methodName);
var invocation = new InvocationExpression(target);
var usedVariables = VariableLookupVisitor.Analyze(context, statements);
var inExtractedRegion = new VariableUsageAnalyzation (context, usedVariables);
var lastStatement = statements [statements.Count - 1];
var stmt = statements [0].GetParent<BlockStatement>();
while (stmt.GetParent<BlockStatement> () != null) {
stmt = stmt.GetParent<BlockStatement>();
}
inExtractedRegion.SetAnalyzedRange(statements [0], lastStatement);
stmt.AcceptVisitor (inExtractedRegion);
var beforeExtractedRegion = new VariableUsageAnalyzation (context, usedVariables);
beforeExtractedRegion.SetAnalyzedRange(statements [0].Parent, statements [0], true, false);
stmt.AcceptVisitor (beforeExtractedRegion);
var afterExtractedRegion = new VariableUsageAnalyzation (context, usedVariables);
afterExtractedRegion.SetAnalyzedRange(lastStatement, stmt.Statements.Last(), false, true);
stmt.AcceptVisitor (afterExtractedRegion);
usedVariables.Sort ((l, r) => l.Region.Begin.CompareTo (r.Region.Begin));
IVariable generatedReturnVariable = null;
foreach (var variable in usedVariables) {
if ((variable is IParameter) || beforeExtractedRegion.Has (variable) || !afterExtractedRegion.Has (variable))
continue;
generatedReturnVariable = variable;
method.ReturnType = context.CreateShortType (variable.Type);
method.Body.Add (new ReturnStatement (new IdentifierExpression (variable.Name)));
break;
}
int parameterOutCount = 0;
foreach (var variable in usedVariables) {
if (!(variable is IParameter) && !beforeExtractedRegion.Has (variable) && !afterExtractedRegion.Has (variable))
continue;
if (variable == generatedReturnVariable)
continue;
Expression argumentExpression = new IdentifierExpression(variable.Name);
ParameterModifier mod = ParameterModifier.None;
if (inExtractedRegion.GetStatus (variable) == VariableState.Changed) {
if (beforeExtractedRegion.GetStatus (variable) == VariableState.None) {
mod = ParameterModifier.Out;
argumentExpression = new DirectionExpression(FieldDirection.Out, argumentExpression);
parameterOutCount++;
} else {
mod = ParameterModifier.Ref;
argumentExpression = new DirectionExpression(FieldDirection.Ref, argumentExpression);
}
}
method.Parameters.Add(new ParameterDeclaration(context.CreateShortType(variable.Type), variable.Name, mod));
invocation.Arguments.Add(argumentExpression);
}
ParameterDeclaration parameterToTransform = null;
bool transformParameterToReturn = method.ReturnType is PrimitiveType &&
((PrimitiveType)method.ReturnType).Keyword == "void" &&
parameterOutCount == 1;
if(transformParameterToReturn) {
parameterToTransform = method.Parameters.First(p => p.ParameterModifier == ParameterModifier.Out);
parameterToTransform.Remove();
var argumentExpression = invocation.Arguments.OfType<DirectionExpression>().First(a => a.FieldDirection == FieldDirection.Out);
argumentExpression.Remove();
method.ReturnType = parameterToTransform.Type.Clone();
var argumentDecl = new VariableDeclarationStatement(parameterToTransform.Type.Clone(),parameterToTransform.Name);
method.Body.InsertChildBefore(method.Body.First(),argumentDecl,BlockStatement.StatementRole);
method.Body.Add(new ReturnStatement (new IdentifierExpression (parameterToTransform.Name)));
}
script
.InsertWithCursor(context.TranslateString("Extract method"), Script.InsertPosition.Before, method)
.ContinueScript(delegate {
foreach (var node in statements.Skip (1)) {
if (node is NewLineNode)
continue;
script.Remove(node);
}
foreach (var variable in usedVariables) {
if ((variable is IParameter) || beforeExtractedRegion.Has (variable) || !afterExtractedRegion.Has (variable))
continue;
if (variable == generatedReturnVariable)
continue;
script.InsertBefore (statements [0], new VariableDeclarationStatement (context.CreateShortType(variable.Type), variable.Name));
}
Statement invocationStatement;
if (generatedReturnVariable != null) {
invocationStatement = new VariableDeclarationStatement (new SimpleType ("var"), generatedReturnVariable.Name, invocation);
} else if(transformParameterToReturn) {
invocationStatement = new AssignmentExpression(new IdentifierExpression(parameterToTransform.Name), invocation);
} else {
invocationStatement = invocation;
}
script.Replace(statements [0], invocationStatement);
script.Link(target, method.NameToken);
});
}, statements.First ().StartLocation, statements.Last ().EndLocation);
}
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;
}
CodeAction CreateFromStatements(RefactoringContext context, List <AstNode> statements)
{
if (!(statements [0].Parent is Statement))
{
return(null);
}
return(new CodeAction(context.TranslateString("Extract method"), script => {
string methodName = "NewMethod";
var method = new MethodDeclaration()
{
ReturnType = new PrimitiveType("void"),
Name = methodName,
Body = new BlockStatement()
};
bool usesNonStaticMember = false;
foreach (var node in statements)
{
usesNonStaticMember |= StaticVisitor.UsesNotStaticMember(context, node);
if (node is Statement)
{
method.Body.Add((Statement)node.Clone());
}
else
{
method.Body.AddChildUnsafe(node.Clone(), node.Role);
}
}
if (!usesNonStaticMember)
{
method.Modifiers |= Modifiers.Static;
}
var target = new IdentifierExpression(methodName);
var invocation = new InvocationExpression(target);
var usedVariables = VariableLookupVisitor.Analyze(context, statements);
var inExtractedRegion = new VariableUsageAnalyzation(context, usedVariables);
var lastStatement = statements [statements.Count - 1];
var stmt = statements [0].GetParent <BlockStatement>();
while (stmt.GetParent <BlockStatement> () != null)
{
stmt = stmt.GetParent <BlockStatement>();
}
inExtractedRegion.SetAnalyzedRange(statements [0], lastStatement);
stmt.AcceptVisitor(inExtractedRegion);
var beforeExtractedRegion = new VariableUsageAnalyzation(context, usedVariables);
beforeExtractedRegion.SetAnalyzedRange(statements [0].Parent, statements [0], true, false);
stmt.AcceptVisitor(beforeExtractedRegion);
var afterExtractedRegion = new VariableUsageAnalyzation(context, usedVariables);
afterExtractedRegion.SetAnalyzedRange(lastStatement, stmt.Statements.Last(), false, true);
stmt.AcceptVisitor(afterExtractedRegion);
usedVariables.Sort((l, r) => l.Region.Begin.CompareTo(r.Region.Begin));
IVariable generatedReturnVariable = null;
foreach (var variable in usedVariables)
{
if ((variable is IParameter) || beforeExtractedRegion.Has(variable) || !afterExtractedRegion.Has(variable))
{
continue;
}
generatedReturnVariable = variable;
method.ReturnType = context.CreateShortType(variable.Type);
method.Body.Add(new ReturnStatement(new IdentifierExpression(variable.Name)));
break;
}
foreach (var variable in usedVariables)
{
if (!(variable is IParameter) && !beforeExtractedRegion.Has(variable) && !afterExtractedRegion.Has(variable))
{
continue;
}
if (variable == generatedReturnVariable)
{
continue;
}
Expression argumentExpression = new IdentifierExpression(variable.Name);
ParameterModifier mod = ParameterModifier.None;
if (inExtractedRegion.GetStatus(variable) == VariableState.Changed)
{
if (beforeExtractedRegion.GetStatus(variable) == VariableState.None)
{
mod = ParameterModifier.Out;
argumentExpression = new DirectionExpression(FieldDirection.Out, argumentExpression);
}
else
{
mod = ParameterModifier.Ref;
argumentExpression = new DirectionExpression(FieldDirection.Ref, argumentExpression);
}
}
method.Parameters.Add(new ParameterDeclaration(context.CreateShortType(variable.Type), variable.Name, mod));
invocation.Arguments.Add(argumentExpression);
}
var task = script.InsertWithCursor(context.TranslateString("Extract method"), Script.InsertPosition.Before, method);
Action <Task> replaceStatements = delegate {
foreach (var node in statements.Skip(1))
{
if (node is NewLineNode)
{
continue;
}
script.Remove(node);
}
foreach (var variable in usedVariables)
{
if ((variable is IParameter) || beforeExtractedRegion.Has(variable) || !afterExtractedRegion.Has(variable))
{
continue;
}
if (variable == generatedReturnVariable)
{
continue;
}
script.InsertBefore(statements [0], new VariableDeclarationStatement(context.CreateShortType(variable.Type), variable.Name));
}
AstNode invocationStatement;
if (generatedReturnVariable != null)
{
invocationStatement = new VariableDeclarationStatement(new SimpleType("var"), generatedReturnVariable.Name, invocation);
}
else
{
invocationStatement = new ExpressionStatement(invocation);
}
script.Replace(statements [0], invocationStatement);
script.Link(target, method.NameToken);
};
if (task.IsCompleted)
{
replaceStatements(null);
}
else
{
task.ContinueWith(replaceStatements, TaskScheduler.FromCurrentSynchronizationContext());
}
}, statements.First().StartLocation, statements.Last().EndLocation));
}
public virtual bool Visit(VariableDeclarationStatement node)
{
return(CommonVisit(node));
}
public override void Visit(VariableDeclarationStatement node)
{
VisitNodes(node.Declarations);
Visit((Statement)node);
WriteEdges(node, node.Declarations, "declaration");
}
void AddTo(IfElseStatement ifElseStatement, VariableDeclarationStatement varDeclaration, Expression expr)
{
}
public virtual Node VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
{
throw new System.NotImplementedException();
}
public override object VisitBlockStatement(BlockStatement blockStatement, object data)
{
int numberOfVariablesOutsideBlock = currentlyUsedVariableNames.Count;
base.VisitBlockStatement(blockStatement, data);
foreach (ExpressionStatement stmt in blockStatement.Statements.OfType <ExpressionStatement>().ToArray())
{
Match displayClassAssignmentMatch = displayClassAssignmentPattern.Match(stmt);
if (!displayClassAssignmentMatch.Success)
{
continue;
}
ILVariable variable = displayClassAssignmentMatch.Get <AstNode>("variable").Single().Annotation <ILVariable>();
if (variable == null)
{
continue;
}
TypeDefinition type = variable.Type.ResolveWithinSameModule();
if (!IsPotentialClosure(context, type))
{
continue;
}
if (displayClassAssignmentMatch.Get <AstType>("type").Single().Annotation <TypeReference>().ResolveWithinSameModule() != type)
{
continue;
}
// Looks like we found a display class creation. Now let's verify that the variable is used only for field accesses:
bool ok = true;
foreach (var identExpr in blockStatement.Descendants.OfType <IdentifierExpression>())
{
if (identExpr.Identifier == variable.Name && identExpr != displayClassAssignmentMatch.Get("variable").Single())
{
if (!(identExpr.Parent is MemberReferenceExpression && identExpr.Parent.Annotation <FieldReference>() != null))
{
ok = false;
}
}
}
if (!ok)
{
continue;
}
Dictionary <FieldReference, AstNode> dict = new Dictionary <FieldReference, AstNode>();
// Delete the variable declaration statement:
VariableDeclarationStatement displayClassVarDecl = PatternStatementTransform.FindVariableDeclaration(stmt, variable.Name);
if (displayClassVarDecl != null)
{
displayClassVarDecl.Remove();
}
// Delete the assignment statement:
AstNode cur = stmt.NextSibling;
stmt.Remove();
// Delete any following statements as long as they assign parameters to the display class
BlockStatement rootBlock = blockStatement.Ancestors.OfType <BlockStatement>().LastOrDefault() ?? blockStatement;
List <ILVariable> parameterOccurrances = rootBlock.Descendants.OfType <IdentifierExpression>()
.Select(n => n.Annotation <ILVariable>()).Where(p => p != null && p.IsParameter).ToList();
AstNode next;
for (; cur != null; cur = next)
{
next = cur.NextSibling;
// Test for the pattern:
// "variableName.MemberName = right;"
ExpressionStatement closureFieldAssignmentPattern = new ExpressionStatement(
new AssignmentExpression(
new NamedNode("left", new MemberReferenceExpression {
Target = new IdentifierExpression(variable.Name)
}),
new AnyNode("right")
)
);
Match m = closureFieldAssignmentPattern.Match(cur);
if (m.Success)
{
FieldDefinition fieldDef = m.Get <MemberReferenceExpression>("left").Single().Annotation <FieldReference>().ResolveWithinSameModule();
AstNode right = m.Get <AstNode>("right").Single();
bool isParameter = false;
bool isDisplayClassParentPointerAssignment = false;
if (right is ThisReferenceExpression)
{
isParameter = true;
}
else if (right is IdentifierExpression)
{
// handle parameters only if the whole method contains no other occurrence except for 'right'
ILVariable v = right.Annotation <ILVariable>();
isParameter = v.IsParameter && parameterOccurrances.Count(c => c == v) == 1;
if (!isParameter && IsPotentialClosure(context, v.Type.ResolveWithinSameModule()))
{
// parent display class within the same method
// (closure2.localsX = closure1;)
isDisplayClassParentPointerAssignment = true;
}
}
else if (right is MemberReferenceExpression)
{
// copy of parent display class reference from an outer lambda
// closure2.localsX = this.localsY
MemberReferenceExpression mre = m.Get <MemberReferenceExpression>("right").Single();
do
{
// descend into the targets of the mre as long as the field types are closures
FieldDefinition fieldDef2 = mre.Annotation <FieldReference>().ResolveWithinSameModule();
if (fieldDef2 == null || !IsPotentialClosure(context, fieldDef2.FieldType.ResolveWithinSameModule()))
{
break;
}
// if we finally get to a this reference, it's copying a display class parent pointer
if (mre.Target is ThisReferenceExpression)
{
isDisplayClassParentPointerAssignment = true;
}
mre = mre.Target as MemberReferenceExpression;
} while (mre != null);
}
if (isParameter || isDisplayClassParentPointerAssignment)
{
dict[fieldDef] = right;
cur.Remove();
}
else
{
break;
}
}
else
{
break;
}
}
// Now create variables for all fields of the display class (except for those that we already handled as parameters)
List <Tuple <AstType, string> > variablesToDeclare = new List <Tuple <AstType, string> >();
foreach (FieldDefinition field in type.Fields)
{
if (field.IsStatic)
{
continue; // skip static fields
}
if (dict.ContainsKey(field)) // skip field if it already was handled as parameter
{
continue;
}
EnsureVariableNameIsAvailable(blockStatement, field.Name);
currentlyUsedVariableNames.Add(field.Name);
variablesToDeclare.Add(Tuple.Create(AstBuilder.ConvertType(field.FieldType, field), field.Name));
dict[field] = new IdentifierExpression(field.Name);
}
// Now figure out where the closure was accessed and use the simpler replacement expression there:
foreach (var identExpr in blockStatement.Descendants.OfType <IdentifierExpression>())
{
if (identExpr.Identifier == variable.Name)
{
MemberReferenceExpression mre = (MemberReferenceExpression)identExpr.Parent;
AstNode replacement;
if (dict.TryGetValue(mre.Annotation <FieldReference>().ResolveWithinSameModule(), out replacement))
{
mre.ReplaceWith(replacement.Clone());
}
}
}
// Now insert the variable declarations (we can do this after the replacements only so that the scope detection works):
Statement insertionPoint = blockStatement.Statements.FirstOrDefault();
foreach (var tuple in variablesToDeclare)
{
var newVarDecl = new VariableDeclarationStatement(tuple.Item1, tuple.Item2);
newVarDecl.Variables.Single().AddAnnotation(new CapturedVariableAnnotation());
blockStatement.Statements.InsertBefore(insertionPoint, newVarDecl);
}
}
currentlyUsedVariableNames.RemoveRange(numberOfVariablesOutsideBlock, currentlyUsedVariableNames.Count - numberOfVariablesOutsideBlock);
return(null);
}
public NotificationChain basicSetVariableDeclarationStatement(VariableDeclarationStatement newobj, NotificationChain msgs)
{
msgs = eBasicSetContainer((InternalEObject)newobj, Java_PackageImpl.MODIFIER_VARIABLEDECLARATIONSTATEMENT, msgs);
return(msgs);
}
public override IEnumerable <Expression> VisitVariableDeclarationStatement(
VariableDeclarationStatement variableDeclarationStatement)
{
return(variableDeclarationStatement.Variables.Select(v => v.Initializer));
}
public override void VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
{
new VariableBlock(this, variableDeclarationStatement).Emit();
}
protected virtual Statement EmitUsing(UsingStatement usingStatement, AstNode expression, IEnumerable <AstNode> inner, VariableDeclarationStatement varStat)
{
string name = null;
BlockStatement wrapper = null;
var varInit = expression as VariableInitializer;
if (varInit != null)
{
name = varInit.Name;
wrapper = new BlockStatement();
wrapper.Statements.Add(new VariableDeclarationStatement(varStat != null ? varStat.Type.Clone() : AstType.Null, varInit.Name, varInit.Initializer.Clone()));
}
else if (expression is IdentifierExpression)
{
name = ((IdentifierExpression)expression).Identifier;
}
else
{
name = this.GetTempVarName();
wrapper = new BlockStatement();
wrapper.Statements.Add(new VariableDeclarationStatement(varStat != null ? varStat.Type.Clone() : AstType.Null, name, expression.Clone() as Expression));
}
var tryCatchStatement = new TryCatchStatement();
if (wrapper != null)
{
wrapper.Statements.Add(tryCatchStatement);
}
if (inner != null && inner.Any())
{
var block = new BlockStatement();
block.Statements.Add(this.EmitUsing(usingStatement, inner.First(), inner.Skip(1), varStat));
tryCatchStatement.TryBlock = block;
}
else
{
var block = usingStatement.EmbeddedStatement as BlockStatement;
if (block == null)
{
block = new BlockStatement();
block.Add(usingStatement.EmbeddedStatement.Clone());
}
else
{
block = (BlockStatement)block.Clone();
}
tryCatchStatement.TryBlock = block;
}
var finallyBlock = new BlockStatement();
var dispose = new InvocationExpression(
new MemberReferenceExpression(
new MemberReferenceExpression(new TypeReferenceExpression(new MemberType(new SimpleType("global"), CS.NS.BRIDGE)
{
IsDoubleColon = true
}), "Script"), "Write"),
new PrimitiveExpression(
string.Format("if (" + JS.Funcs.BRIDGE_HASVALUE + "({0})) {0}." + JS.Funcs.DISPOSE + "();", name))
);
finallyBlock.Statements.Add(dispose);
tryCatchStatement.FinallyBlock = finallyBlock;
return(wrapper ?? (Statement)tryCatchStatement);
}
public void NestedPointers()
{
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement <VariableDeclarationStatement>("DateTime*** a;");
Assert.IsTrue(new VariableDeclarationStatement(new SimpleType("DateTime").MakePointerType().MakePointerType().MakePointerType(), "a").IsMatch(lvd));
}
void TransformBody(List <InvocationExpression> validInvocations, bool isVoid, bool isParameterizedTask, InvocationExpression returnedContinuation, string taskCompletionSourceIdentifier, BlockStatement blockStatement)
{
if (!isVoid)
{
if (returnedContinuation == null)
{
//Is TaskCompletionSource-based
blockStatement.Statements.First().Remove(); //Remove task completion source declaration
blockStatement.Statements.Last().Remove(); //Remove final return
}
//We use ToList() because we will be modifying the original collection
foreach (var expressionStatement in blockStatement.Descendants.OfType <ExpressionStatement>().ToList())
{
var invocationExpression = expressionStatement.Expression as InvocationExpression;
if (invocationExpression == null || invocationExpression.Arguments.Count != 1)
{
continue;
}
var target = invocationExpression.Target as MemberReferenceExpression;
if (target == null || target.MemberName != "SetResult")
{
continue;
}
var targetExpression = target.Target as IdentifierExpression;
if (targetExpression == null || targetExpression.Identifier != taskCompletionSourceIdentifier)
{
continue;
}
var returnedExpression = invocationExpression.Arguments.Single();
returnedExpression.Remove();
var originalInvocation = (InvocationExpression)invocationExpression.Annotation <OriginalNodeAnnotation>().sourceNode;
var originalReturnedExpression = originalInvocation.Arguments.Single();
var argumentType = ctx.Resolve(originalReturnedExpression).Type;
if (!isParameterizedTask)
{
var parent = expressionStatement.Parent;
var resultIdentifier = CreateVariableName(blockStatement, "result");
var blockParent = parent as BlockStatement;
var resultDeclarationType = argumentType == SpecialType.NullType ? new PrimitiveType("object") : CreateShortType(originalInvocation, argumentType);
var declaration = new VariableDeclarationStatement(resultDeclarationType, resultIdentifier, returnedExpression);
if (blockParent == null)
{
var newStatement = new BlockStatement();
newStatement.Add(declaration);
newStatement.Add(new ReturnStatement());
expressionStatement.ReplaceWith(newStatement);
}
else
{
blockParent.Statements.InsertAfter(expressionStatement, new ReturnStatement());
expressionStatement.ReplaceWith(declaration);
}
}
else
{
var newStatement = new ReturnStatement(returnedExpression);
expressionStatement.ReplaceWith(newStatement);
}
}
}
//Find all instances of ContinueWith to replace and associated
var continuations = new List <Tuple <InvocationExpression, InvocationExpression, string> >();
foreach (var invocation in blockStatement.Descendants.OfType <InvocationExpression>())
{
if (invocation.Arguments.Count != 1)
{
continue;
}
var originalInvocation = (InvocationExpression)invocation.Annotation <OriginalNodeAnnotation>().sourceNode;
if (!validInvocations.Contains(originalInvocation))
{
continue;
}
var lambda = invocation.Arguments.Single();
string associatedTaskName = null;
var lambdaParameters = lambda.GetChildrenByRole(Roles.Parameter).Select(p => p.Name).ToList();
var lambdaTaskParameterName = lambdaParameters.FirstOrDefault();
if (lambdaTaskParameterName != null)
{
associatedTaskName = lambdaTaskParameterName;
}
continuations.Add(Tuple.Create(invocation, originalInvocation, associatedTaskName));
}
foreach (var continuationTuple in continuations)
{
string taskName = continuationTuple.Item3 ?? "task";
string effectiveTaskName = CreateVariableName(blockStatement, taskName);
string resultName = CreateVariableName(blockStatement, taskName + "Result");
var continuation = continuationTuple.Item1;
var originalInvocation = continuationTuple.Item2;
var target = continuation.Target.GetChildByRole(Roles.TargetExpression).Detach();
var awaitedExpression = new UnaryOperatorExpression(UnaryOperatorType.Await, target);
var replacements = new List <Statement>();
var lambdaExpression = originalInvocation.Arguments.First();
var continuationLambdaResolveResult = (LambdaResolveResult)ctx.Resolve(lambdaExpression);
if (!continuationLambdaResolveResult.HasParameterList)
{
//Lambda has no parameter, so creating a variable for the argument is not needed
// (since you can't use an argument that doesn't exist).
replacements.Add(new ExpressionStatement(awaitedExpression));
}
else
{
//Lambda has a parameter, which can either be a Task or a Task<T>.
var lambdaParameter = continuationLambdaResolveResult.Parameters[0];
bool isTaskIdentifierUsed = lambdaExpression.Descendants.OfType <IdentifierExpression>().Any(identifier => {
if (identifier.Identifier != lambdaParameter.Name)
{
return(false);
}
var identifierMre = identifier.Parent as MemberReferenceExpression;
return(identifierMre == null || identifierMre.MemberName != "Result");
});
var precedentTaskType = lambdaParameter.Type;
//We might need to separate the task creation and awaiting
if (isTaskIdentifierUsed)
{
//Create new task variable
var taskExpression = awaitedExpression.Expression;
taskExpression.Detach();
replacements.Add(new VariableDeclarationStatement(CreateShortType(lambdaExpression, precedentTaskType),
effectiveTaskName,
taskExpression));
awaitedExpression.Expression = new IdentifierExpression(effectiveTaskName);
}
if (precedentTaskType.IsParameterized)
{
//precedent is Task<T>
var precedentResultType = precedentTaskType.TypeArguments.First();
replacements.Add(new VariableDeclarationStatement(CreateShortType(originalInvocation, precedentResultType), resultName, awaitedExpression));
}
else
{
//precedent is Task
replacements.Add(awaitedExpression);
}
}
var parentStatement = continuation.GetParent <Statement>();
var grandParentStatement = parentStatement.Parent;
var block = grandParentStatement as BlockStatement;
if (block == null)
{
block = new BlockStatement();
block.Statements.AddRange(replacements);
parentStatement.ReplaceWith(block);
}
else
{
foreach (var replacement in replacements)
{
block.Statements.InsertBefore(parentStatement, replacement);
}
parentStatement.Remove();
}
var lambdaOrDelegate = continuation.Arguments.Single();
Statement lambdaContent;
if (lambdaOrDelegate is LambdaExpression)
{
lambdaContent = (Statement)lambdaOrDelegate.GetChildByRole(LambdaExpression.BodyRole);
}
else
{
lambdaContent = lambdaOrDelegate.GetChildByRole(Roles.Body);
}
foreach (var identifierExpression in lambdaContent.Descendants.OfType <IdentifierExpression>())
{
if (continuationTuple.Item3 != identifierExpression.Identifier)
{
continue;
}
var memberReference = identifierExpression.Parent as MemberReferenceExpression;
if (memberReference == null || memberReference.MemberName != "Result")
{
identifierExpression.ReplaceWith(new IdentifierExpression(effectiveTaskName));
continue;
}
memberReference.ReplaceWith(new IdentifierExpression(resultName));
}
if (lambdaContent is BlockStatement)
{
Statement previousStatement = replacements.Last();
foreach (var statementInContinuation in lambdaContent.GetChildrenByRole(BlockStatement.StatementRole))
{
statementInContinuation.Detach();
block.Statements.InsertAfter(previousStatement, statementInContinuation);
previousStatement = statementInContinuation;
}
}
else
{
lambdaContent.Detach();
block.Statements.InsertAfter(replacements.Last(), lambdaContent);
}
}
}
public VariableBlock(IEmitter emitter, VariableDeclarationStatement variableDeclarationStatement)
: base(emitter, variableDeclarationStatement)
{
this.Emitter = emitter;
this.VariableDeclarationStatement = variableDeclarationStatement;
}
public virtual void EndVisit(VariableDeclarationStatement node)
{
CommonEndVisit(node);
}
public override ControlFlowNode VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, ControlFlowNode data)
{
return(CreateConnectedEndNode(variableDeclarationStatement, data));
}
public virtual void VisitVariableDeclarationStatement(VariableDeclarationStatement node) => DefaultVisit(node);
public virtual void Visit(VariableDeclarationStatement expression)
{
logVisit(expression);
}
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 visitor = new DeclareLocalVariableAction.SearchNodeVisitior(pexpr);
var node = context.GetNode <BlockStatement>();
if (node != null)
{
node.AcceptVisitor(visitor);
}
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);
}, pexpr));
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);
}, pexpr));
if (visitor.Matches.Count > 1)
{
yield return(new CodeAction(string.Format(context.TranslateString("Create local constant (replace '{0}' occurrences)"), visitor.Matches.Count), 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 linkedNodes = new List <AstNode>();
linkedNodes.Add(initializer.NameToken);
for (int i = 0; i < visitor.Matches.Count; i++)
{
var identifierExpression = new IdentifierExpression(name);
linkedNodes.Add(identifierExpression);
script.Replace(visitor.Matches [i], identifierExpression);
}
script.Link(linkedNodes.ToArray());
}, pexpr));
yield return(new CodeAction(string.Format(context.TranslateString("Create constant field (replace '{0}' occurrences)"), visitor.Matches.Count), 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 linkedNodes = new List <AstNode>();
linkedNodes.Add(initializer.NameToken);
for (int i = 0; i < visitor.Matches.Count; i++)
{
var identifierExpression = new IdentifierExpression(name);
linkedNodes.Add(identifierExpression);
script.Replace(visitor.Matches [i], identifierExpression);
}
script.InsertWithCursor(context.TranslateString("Create constant"), Script.InsertPosition.Before, decl);
}, pexpr));
}
}
public void VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
{
StartNode(variableDeclarationStatement);
WriteModifiers(variableDeclarationStatement.GetChildrenByRole(VariableDeclarationStatement.ModifierRole));
variableDeclarationStatement.Type.AcceptVisitor(this);
Space();
WriteCommaSeparatedList(variableDeclarationStatement.Variables);
Semicolon();
EndNode(variableDeclarationStatement);
}
public override void Visit(VariableDeclarationStatement node)
{
PushLocation(node);
VisitNodes(node.Declarations);
PopLocation();
}
public VariableBlock(IEmitter emitter, VariableDeclarationStatement variableDeclarationStatement)
: base(emitter, variableDeclarationStatement)
{
this.Emitter = emitter;
this.VariableDeclarationStatement = variableDeclarationStatement;
}
public override object VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
{
FixStatementIndentation(variableDeclarationStatement.StartLocation);
return(null);
}
