mirror of https://github.com/icsharpcode/ILSpy.git
Eusebiu Marcu
15 years ago
17 changed files with 1483 additions and 44 deletions
@ -0,0 +1,132 @@
@@ -0,0 +1,132 @@
|
||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
||||
|
||||
using System; |
||||
using System.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Analysis |
||||
{ |
||||
[TestFixture] |
||||
public class DefiniteAssignmentTests |
||||
{ |
||||
[Test] |
||||
public void TryFinally() |
||||
{ |
||||
BlockStatement block = new BlockStatement { |
||||
new TryCatchStatement { |
||||
TryBlock = new BlockStatement { |
||||
new GotoStatement("LABEL"), |
||||
new AssignmentExpression(new IdentifierExpression("i"), new PrimitiveExpression(1)) |
||||
}, |
||||
CatchClauses = { |
||||
new CatchClause { |
||||
Body = new BlockStatement { |
||||
new AssignmentExpression(new IdentifierExpression("i"), new PrimitiveExpression(3)) |
||||
} |
||||
} |
||||
}, |
||||
FinallyBlock = new BlockStatement { |
||||
new AssignmentExpression(new IdentifierExpression("j"), new PrimitiveExpression(5)) |
||||
} |
||||
}, |
||||
new LabelStatement { Label = "LABEL" }, |
||||
new EmptyStatement() |
||||
}; |
||||
TryCatchStatement tryCatchStatement = (TryCatchStatement)block.Statements.First(); |
||||
Statement stmt1 = tryCatchStatement.TryBlock.Statements.ElementAt(1); |
||||
Statement stmt3 = tryCatchStatement.CatchClauses.Single().Body.Statements.Single(); |
||||
Statement stmt5 = tryCatchStatement.FinallyBlock.Statements.Single(); |
||||
LabelStatement label = (LabelStatement)block.Statements.ElementAt(1); |
||||
|
||||
DefiniteAssignmentAnalysis da = new DefiniteAssignmentAnalysis(block); |
||||
da.Analyze("i"); |
||||
Assert.AreEqual(0, da.UnassignedVariableUses.Count); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(tryCatchStatement)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.CodeUnreachable, da.GetStatusBefore(stmt1)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.CodeUnreachable, da.GetStatusAfter(stmt1)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(stmt3)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusAfter(stmt3)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(stmt5)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusAfter(stmt5)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusAfter(tryCatchStatement)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusBefore(label)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusAfter(label)); |
||||
|
||||
da.Analyze("j"); |
||||
Assert.AreEqual(0, da.UnassignedVariableUses.Count); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(tryCatchStatement)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.CodeUnreachable, da.GetStatusBefore(stmt1)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.CodeUnreachable, da.GetStatusAfter(stmt1)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(stmt3)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusAfter(stmt3)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(stmt5)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusAfter(stmt5)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusAfter(tryCatchStatement)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusBefore(label)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusAfter(label)); |
||||
} |
||||
|
||||
[Test] |
||||
public void ConditionalAnd() |
||||
{ |
||||
IfElseStatement ifStmt = new IfElseStatement { |
||||
Condition = new BinaryOperatorExpression { |
||||
Left = new BinaryOperatorExpression(new IdentifierExpression("x"), BinaryOperatorType.GreaterThan, new PrimitiveExpression(0)), |
||||
Operator = BinaryOperatorType.ConditionalAnd, |
||||
Right = new BinaryOperatorExpression { |
||||
Left = new ParenthesizedExpression { |
||||
Expression = new AssignmentExpression { |
||||
Left = new IdentifierExpression("i"), |
||||
Operator = AssignmentOperatorType.Assign, |
||||
Right = new IdentifierExpression("y") |
||||
} |
||||
}, |
||||
Operator = BinaryOperatorType.GreaterThanOrEqual, |
||||
Right = new PrimitiveExpression(0) |
||||
} |
||||
}, |
||||
TrueStatement = new BlockStatement(), |
||||
FalseStatement = new BlockStatement() |
||||
}; |
||||
DefiniteAssignmentAnalysis da = new DefiniteAssignmentAnalysis(ifStmt); |
||||
da.Analyze("i"); |
||||
Assert.AreEqual(0, da.UnassignedVariableUses.Count); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(ifStmt)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusBefore(ifStmt.TrueStatement)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(ifStmt.FalseStatement)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusAfter(ifStmt)); |
||||
} |
||||
|
||||
[Test] |
||||
public void ConditionalOr() |
||||
{ |
||||
IfElseStatement ifStmt = new IfElseStatement { |
||||
Condition = new BinaryOperatorExpression { |
||||
Left = new BinaryOperatorExpression(new IdentifierExpression("x"), BinaryOperatorType.GreaterThan, new PrimitiveExpression(0)), |
||||
Operator = BinaryOperatorType.ConditionalOr, |
||||
Right = new BinaryOperatorExpression { |
||||
Left = new ParenthesizedExpression { |
||||
Expression = new AssignmentExpression { |
||||
Left = new IdentifierExpression("i"), |
||||
Operator = AssignmentOperatorType.Assign, |
||||
Right = new IdentifierExpression("y") |
||||
} |
||||
}, |
||||
Operator = BinaryOperatorType.GreaterThanOrEqual, |
||||
Right = new PrimitiveExpression(0) |
||||
} |
||||
}, |
||||
TrueStatement = new BlockStatement(), |
||||
FalseStatement = new BlockStatement() |
||||
}; |
||||
DefiniteAssignmentAnalysis da = new DefiniteAssignmentAnalysis(ifStmt); |
||||
da.Analyze("i"); |
||||
Assert.AreEqual(0, da.UnassignedVariableUses.Count); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(ifStmt)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusBefore(ifStmt.TrueStatement)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.DefinitelyAssigned, da.GetStatusBefore(ifStmt.FalseStatement)); |
||||
Assert.AreEqual(DefiniteAssignmentStatus.PotentiallyAssigned, da.GetStatusAfter(ifStmt)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,638 @@
@@ -0,0 +1,638 @@
|
||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
||||
|
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Diagnostics; |
||||
using System.Linq; |
||||
using ICSharpCode.NRefactory.CSharp.Resolver; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Analysis |
||||
{ |
||||
/// <summary>
|
||||
/// Represents a node in the control flow graph of a C# method.
|
||||
/// </summary>
|
||||
public class ControlFlowNode |
||||
{ |
||||
public readonly Statement PreviousStatement; |
||||
public readonly Statement NextStatement; |
||||
|
||||
public readonly ControlFlowNodeType Type; |
||||
|
||||
public readonly List<ControlFlowEdge> Outgoing = new List<ControlFlowEdge>(); |
||||
public readonly List<ControlFlowEdge> Incoming = new List<ControlFlowEdge>(); |
||||
|
||||
public ControlFlowNode(Statement previousStatement, Statement nextStatement, ControlFlowNodeType type) |
||||
{ |
||||
if (previousStatement == null && nextStatement == null) |
||||
throw new ArgumentException("previousStatement and nextStatement must not be both null"); |
||||
this.PreviousStatement = previousStatement; |
||||
this.NextStatement = nextStatement; |
||||
this.Type = type; |
||||
} |
||||
} |
||||
|
||||
public enum ControlFlowNodeType |
||||
{ |
||||
/// <summary>
|
||||
/// Unknown node type
|
||||
/// </summary>
|
||||
None, |
||||
/// <summary>
|
||||
/// Node in front of a statement
|
||||
/// </summary>
|
||||
StartNode, |
||||
/// <summary>
|
||||
/// Node between two statements
|
||||
/// </summary>
|
||||
BetweenStatements, |
||||
/// <summary>
|
||||
/// Node at the end of a statement list
|
||||
/// </summary>
|
||||
EndNode, |
||||
/// <summary>
|
||||
/// Node representing the position before evaluating the condition of a loop.
|
||||
/// </summary>
|
||||
LoopCondition |
||||
} |
||||
|
||||
public class ControlFlowEdge |
||||
{ |
||||
public readonly ControlFlowNode From; |
||||
public readonly ControlFlowNode To; |
||||
public readonly ControlFlowEdgeType Type; |
||||
|
||||
List<TryCatchStatement> jumpOutOfTryFinally; |
||||
|
||||
public ControlFlowEdge(ControlFlowNode from, ControlFlowNode to, ControlFlowEdgeType type) |
||||
{ |
||||
if (from == null) |
||||
throw new ArgumentNullException("from"); |
||||
if (to == null) |
||||
throw new ArgumentNullException("to"); |
||||
this.From = from; |
||||
this.To = to; |
||||
this.Type = type; |
||||
} |
||||
|
||||
internal void AddJumpOutOfTryFinally(TryCatchStatement tryFinally) |
||||
{ |
||||
if (jumpOutOfTryFinally == null) |
||||
jumpOutOfTryFinally = new List<TryCatchStatement>(); |
||||
jumpOutOfTryFinally.Add(tryFinally); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Gets whether this control flow edge is leaving any try-finally statements.
|
||||
/// </summary>
|
||||
public bool IsLeavingTryFinally { |
||||
get { return jumpOutOfTryFinally != null; } |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Gets the try-finally statements that this control flow edge is leaving.
|
||||
/// </summary>
|
||||
public IEnumerable<TryCatchStatement> TryFinallyStatements { |
||||
get { return jumpOutOfTryFinally ?? Enumerable.Empty<TryCatchStatement>(); } |
||||
} |
||||
} |
||||
|
||||
public enum ControlFlowEdgeType |
||||
{ |
||||
/// <summary>
|
||||
/// Regular control flow.
|
||||
/// </summary>
|
||||
Normal, |
||||
/// <summary>
|
||||
/// Conditional control flow (edge taken if condition is true)
|
||||
/// </summary>
|
||||
ConditionTrue, |
||||
/// <summary>
|
||||
/// Conditional control flow (edge taken if condition is false)
|
||||
/// </summary>
|
||||
ConditionFalse, |
||||
/// <summary>
|
||||
/// A jump statement (goto, goto case, break or continue)
|
||||
/// </summary>
|
||||
Jump |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Constructs the control flow graph for C# statements.
|
||||
/// </summary>
|
||||
public class ControlFlowGraphBuilder |
||||
{ |
||||
// Written according to the reachability rules in the C# spec (§8.1 End points and reachability)
|
||||
|
||||
protected virtual ControlFlowNode CreateNode(Statement previousStatement, Statement nextStatement, ControlFlowNodeType type) |
||||
{ |
||||
return new ControlFlowNode(previousStatement, nextStatement, type); |
||||
} |
||||
|
||||
protected virtual ControlFlowEdge CreateEdge(ControlFlowNode from, ControlFlowNode to, ControlFlowEdgeType type) |
||||
{ |
||||
return new ControlFlowEdge(from, to, type); |
||||
} |
||||
|
||||
Statement rootStatement; |
||||
List<ControlFlowNode> nodes; |
||||
Dictionary<string, ControlFlowNode> labels; |
||||
List<ControlFlowNode> gotoStatements; |
||||
|
||||
public IList<ControlFlowNode> BuildControlFlowGraph(Statement statement) |
||||
{ |
||||
NodeCreationVisitor nodeCreationVisitor = new NodeCreationVisitor(); |
||||
nodeCreationVisitor.builder = this; |
||||
try { |
||||
this.nodes = new List<ControlFlowNode>(); |
||||
this.labels = new Dictionary<string, ControlFlowNode>(); |
||||
this.gotoStatements = new List<ControlFlowNode>(); |
||||
this.rootStatement = statement; |
||||
ControlFlowNode entryPoint = CreateStartNode(statement); |
||||
statement.AcceptVisitor(nodeCreationVisitor, entryPoint); |
||||
|
||||
// Resolve goto statements:
|
||||
foreach (ControlFlowNode gotoStmt in gotoStatements) { |
||||
string label = ((GotoStatement)gotoStmt.NextStatement).Label; |
||||
ControlFlowNode labelNode; |
||||
if (labels.TryGetValue(label, out labelNode)) |
||||
nodeCreationVisitor.Connect(gotoStmt, labelNode, ControlFlowEdgeType.Jump); |
||||
} |
||||
|
||||
AnnotateLeaveEdgesWithTryFinallyBlocks(); |
||||
|
||||
return nodes; |
||||
} finally { |
||||
this.nodes = null; |
||||
this.labels = null; |
||||
this.gotoStatements = null; |
||||
this.rootStatement = null; |
||||
} |
||||
} |
||||
|
||||
void AnnotateLeaveEdgesWithTryFinallyBlocks() |
||||
{ |
||||
foreach (ControlFlowEdge edge in nodes.SelectMany(n => n.Outgoing)) { |
||||
if (edge.Type != ControlFlowEdgeType.Jump) { |
||||
// Only jumps are potential candidates for leaving try-finally blocks.
|
||||
// Note that the regular edges leaving try or catch blocks are already annotated by the visitor.
|
||||
continue; |
||||
} |
||||
Statement gotoStatement = edge.From.NextStatement; |
||||
Debug.Assert(gotoStatement is GotoStatement || gotoStatement is GotoDefaultStatement || gotoStatement is GotoCaseStatement || gotoStatement is BreakStatement || gotoStatement is ContinueStatement); |
||||
Statement targetStatement = edge.To.PreviousStatement ?? edge.To.NextStatement; |
||||
if (gotoStatement.Parent == targetStatement.Parent) |
||||
continue; |
||||
HashSet<TryCatchStatement> targetParentTryCatch = new HashSet<TryCatchStatement>(targetStatement.Ancestors.OfType<TryCatchStatement>()); |
||||
for (AstNode node = gotoStatement.Parent; node != null; node = node.Parent) { |
||||
TryCatchStatement leftTryCatch = node as TryCatchStatement; |
||||
if (leftTryCatch != null) { |
||||
if (targetParentTryCatch.Contains(leftTryCatch)) |
||||
break; |
||||
if (!leftTryCatch.FinallyBlock.IsNull) |
||||
edge.AddJumpOutOfTryFinally(leftTryCatch); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
#region Create*Node
|
||||
ControlFlowNode CreateStartNode(Statement statement) |
||||
{ |
||||
ControlFlowNode node = CreateNode(null, statement, ControlFlowNodeType.StartNode); |
||||
nodes.Add(node); |
||||
return node; |
||||
} |
||||
|
||||
ControlFlowNode CreateSpecialNode(Statement statement, ControlFlowNodeType type) |
||||
{ |
||||
ControlFlowNode node = CreateNode(statement, null, type); |
||||
nodes.Add(node); |
||||
return node; |
||||
} |
||||
|
||||
ControlFlowNode CreateEndNode(Statement statement) |
||||
{ |
||||
Statement nextStatement; |
||||
if (statement == rootStatement) { |
||||
nextStatement = null; |
||||
} else { |
||||
// Find the next statement in the same role:
|
||||
AstNode next = statement; |
||||
do { |
||||
next = next.NextSibling; |
||||
} while (next != null && next.Role != statement.Role); |
||||
nextStatement = next as Statement; |
||||
} |
||||
ControlFlowNodeType type = nextStatement != null ? ControlFlowNodeType.BetweenStatements : ControlFlowNodeType.EndNode; |
||||
ControlFlowNode node = CreateNode(statement, nextStatement, type); |
||||
nodes.Add(node); |
||||
return node; |
||||
} |
||||
#endregion
|
||||
|
||||
#region Constant evaluation
|
||||
/// <summary>
|
||||
/// Evaluates an expression.
|
||||
/// </summary>
|
||||
/// <returns>The constant value of the expression; or null if the expression is not a constant.</returns>
|
||||
ConstantResolveResult EvaluateConstant(Expression expr) |
||||
{ |
||||
return null; // TODO: implement this using the C# resolver
|
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Evaluates an expression.
|
||||
/// </summary>
|
||||
/// <returns>The value of the constant boolean expression; or null if the value is not a constant boolean expression.</returns>
|
||||
bool? EvaluateCondition(Expression expr) |
||||
{ |
||||
ConstantResolveResult crr = EvaluateConstant(expr); |
||||
if (crr != null) |
||||
return crr.ConstantValue as bool?; |
||||
else |
||||
return null; |
||||
} |
||||
|
||||
bool AreEqualConstants(ConstantResolveResult c1, ConstantResolveResult c2) |
||||
{ |
||||
return false; // TODO: implement this using the resolver's operator==
|
||||
} |
||||
#endregion
|
||||
|
||||
sealed class NodeCreationVisitor : DepthFirstAstVisitor<ControlFlowNode, ControlFlowNode> |
||||
{ |
||||
// 'data' parameter: input control flow node (start of statement being visited)
|
||||
// Return value: result control flow node (end of statement being visited)
|
||||
|
||||
internal ControlFlowGraphBuilder builder; |
||||
Stack<ControlFlowNode> breakTargets = new Stack<ControlFlowNode>(); |
||||
Stack<ControlFlowNode> continueTargets = new Stack<ControlFlowNode>(); |
||||
List<ControlFlowNode> gotoCaseOrDefault = new List<ControlFlowNode>(); |
||||
|
||||
internal ControlFlowEdge Connect(ControlFlowNode from, ControlFlowNode to, ControlFlowEdgeType type = ControlFlowEdgeType.Normal) |
||||
{ |
||||
ControlFlowEdge edge = builder.CreateEdge(from, to, type); |
||||
from.Outgoing.Add(edge); |
||||
to.Incoming.Add(edge); |
||||
return edge; |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Creates an end node for <c>stmt</c> and connects <c>from</c> with the new node.
|
||||
/// </summary>
|
||||
ControlFlowNode CreateConnectedEndNode(Statement stmt, ControlFlowNode from) |
||||
{ |
||||
ControlFlowNode newNode = builder.CreateEndNode(stmt); |
||||
Connect(from, newNode); |
||||
return newNode; |
||||
} |
||||
|
||||
protected override ControlFlowNode VisitChildren(AstNode node, ControlFlowNode data) |
||||
{ |
||||
// We have overrides for all possible expressions and should visit expressions only.
|
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitBlockStatement(BlockStatement blockStatement, ControlFlowNode data) |
||||
{ |
||||
// C# 4.0 spec: §8.2 Blocks
|
||||
ControlFlowNode childNode = HandleStatementList(blockStatement.Statements, data); |
||||
return CreateConnectedEndNode(blockStatement, childNode); |
||||
} |
||||
|
||||
ControlFlowNode HandleStatementList(AstNodeCollection<Statement> statements, ControlFlowNode source) |
||||
{ |
||||
ControlFlowNode childNode = null; |
||||
foreach (Statement stmt in statements) { |
||||
if (childNode == null) { |
||||
childNode = builder.CreateStartNode(stmt); |
||||
Connect(source, childNode); |
||||
} |
||||
Debug.Assert(childNode.NextStatement == stmt); |
||||
childNode = stmt.AcceptVisitor(this, childNode); |
||||
Debug.Assert(childNode.PreviousStatement == stmt); |
||||
} |
||||
return childNode ?? source; |
||||
} |
||||
|
||||
public override ControlFlowNode VisitEmptyStatement(EmptyStatement emptyStatement, ControlFlowNode data) |
||||
{ |
||||
return CreateConnectedEndNode(emptyStatement, data); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitLabelStatement(LabelStatement labelStatement, ControlFlowNode data) |
||||
{ |
||||
ControlFlowNode end = CreateConnectedEndNode(labelStatement, data); |
||||
builder.labels[labelStatement.Label] = end; |
||||
return end; |
||||
} |
||||
|
||||
public override ControlFlowNode VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, ControlFlowNode data) |
||||
{ |
||||
return CreateConnectedEndNode(variableDeclarationStatement, data); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitExpressionStatement(ExpressionStatement expressionStatement, ControlFlowNode data) |
||||
{ |
||||
return CreateConnectedEndNode(expressionStatement, data); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitIfElseStatement(IfElseStatement ifElseStatement, ControlFlowNode data) |
||||
{ |
||||
bool? cond = builder.EvaluateCondition(ifElseStatement.Condition); |
||||
ControlFlowNode trueBegin = builder.CreateStartNode(ifElseStatement.TrueStatement); |
||||
if (cond != false) |
||||
Connect(data, trueBegin, ControlFlowEdgeType.ConditionTrue); |
||||
ControlFlowNode trueEnd = ifElseStatement.TrueStatement.AcceptVisitor(this, trueBegin); |
||||
ControlFlowNode falseEnd; |
||||
if (ifElseStatement.FalseStatement.IsNull) { |
||||
falseEnd = null; |
||||
} else { |
||||
ControlFlowNode falseBegin = builder.CreateStartNode(ifElseStatement.FalseStatement); |
||||
if (cond != true) |
||||
Connect(data, falseBegin, ControlFlowEdgeType.ConditionFalse); |
||||
falseEnd = ifElseStatement.FalseStatement.AcceptVisitor(this, falseBegin); |
||||
} |
||||
ControlFlowNode end = builder.CreateEndNode(ifElseStatement); |
||||
Connect(trueEnd, end); |
||||
if (falseEnd != null) { |
||||
Connect(falseEnd, end); |
||||
} else if (cond != true) { |
||||
Connect(data, end, ControlFlowEdgeType.ConditionFalse); |
||||
} |
||||
return end; |
||||
} |
||||
|
||||
public override ControlFlowNode VisitSwitchStatement(SwitchStatement switchStatement, ControlFlowNode data) |
||||
{ |
||||
// First, figure out which switch section will get called (if the expression is constant):
|
||||
ConstantResolveResult constant = builder.EvaluateConstant(switchStatement.Expression); |
||||
SwitchSection defaultSection = null; |
||||
SwitchSection sectionMatchedByConstant = null; |
||||
foreach (SwitchSection section in switchStatement.SwitchSections) { |
||||
foreach (CaseLabel label in section.CaseLabels) { |
||||
if (label.Expression.IsNull) { |
||||
defaultSection = section; |
||||
} else if (constant != null) { |
||||
ConstantResolveResult labelConstant = builder.EvaluateConstant(label.Expression); |
||||
if (builder.AreEqualConstants(constant, labelConstant)) |
||||
sectionMatchedByConstant = section; |
||||
} |
||||
} |
||||
} |
||||
if (constant != null && sectionMatchedByConstant == null) |
||||
sectionMatchedByConstant = defaultSection; |
||||
|
||||
int gotoCaseOrDefaultInOuterScope = gotoCaseOrDefault.Count; |
||||
|
||||
ControlFlowNode end = builder.CreateEndNode(switchStatement); |
||||
breakTargets.Push(end); |
||||
foreach (SwitchSection section in switchStatement.SwitchSections) { |
||||
if (constant == null || section == sectionMatchedByConstant) { |
||||
HandleStatementList(section.Statements, data); |
||||
} else { |
||||
// This section is unreachable: pass null to HandleStatementList.
|
||||
HandleStatementList(section.Statements, null); |
||||
} |
||||
// Don't bother connecting the ends of the sections: the 'break' statement takes care of that.
|
||||
} |
||||
breakTargets.Pop(); |
||||
if (defaultSection == null && sectionMatchedByConstant == null) { |
||||
Connect(data, end); |
||||
} |
||||
|
||||
if (gotoCaseOrDefault.Count > gotoCaseOrDefaultInOuterScope) { |
||||
// Resolve 'goto case' statements:
|
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
return end; |
||||
} |
||||
|
||||
public override ControlFlowNode VisitGotoCaseStatement(GotoCaseStatement gotoCaseStatement, ControlFlowNode data) |
||||
{ |
||||
gotoCaseOrDefault.Add(data); |
||||
return builder.CreateEndNode(gotoCaseStatement); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitGotoDefaultStatement(GotoDefaultStatement gotoDefaultStatement, ControlFlowNode data) |
||||
{ |
||||
gotoCaseOrDefault.Add(data); |
||||
return builder.CreateEndNode(gotoDefaultStatement); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitWhileStatement(WhileStatement whileStatement, ControlFlowNode data) |
||||
{ |
||||
// <data> <condition> while (cond) { <bodyStart> embeddedStmt; <bodyEnd> } <end>
|
||||
ControlFlowNode end = builder.CreateEndNode(whileStatement); |
||||
ControlFlowNode conditionNode = builder.CreateSpecialNode(whileStatement, ControlFlowNodeType.LoopCondition); |
||||
breakTargets.Push(end); |
||||
continueTargets.Push(conditionNode); |
||||
|
||||
Connect(data, conditionNode); |
||||
|
||||
bool? cond = builder.EvaluateCondition(whileStatement.Condition); |
||||
ControlFlowNode bodyStart = builder.CreateStartNode(whileStatement.EmbeddedStatement); |
||||
if (cond != false) |
||||
Connect(conditionNode, bodyStart, ControlFlowEdgeType.ConditionTrue); |
||||
ControlFlowNode bodyEnd = whileStatement.EmbeddedStatement.AcceptVisitor(this, bodyStart); |
||||
Connect(bodyEnd, conditionNode); |
||||
if (cond != true) |
||||
Connect(conditionNode, end, ControlFlowEdgeType.ConditionFalse); |
||||
|
||||
breakTargets.Pop(); |
||||
continueTargets.Pop(); |
||||
return end; |
||||
} |
||||
|
||||
public override ControlFlowNode VisitDoWhileStatement(DoWhileStatement doWhileStatement, ControlFlowNode data) |
||||
{ |
||||
// <data> do { <bodyStart> embeddedStmt; <bodyEnd>} <condition> while(cond); <end>
|
||||
ControlFlowNode end = builder.CreateEndNode(doWhileStatement); |
||||
ControlFlowNode conditionNode = builder.CreateSpecialNode(doWhileStatement, ControlFlowNodeType.LoopCondition); |
||||
breakTargets.Push(end); |
||||
continueTargets.Push(conditionNode); |
||||
|
||||
ControlFlowNode bodyStart = builder.CreateStartNode(doWhileStatement.EmbeddedStatement); |
||||
Connect(data, bodyStart); |
||||
ControlFlowNode bodyEnd = doWhileStatement.EmbeddedStatement.AcceptVisitor(this, bodyStart); |
||||
Connect(bodyEnd, conditionNode); |
||||
|
||||
bool? cond = builder.EvaluateCondition(doWhileStatement.Condition); |
||||
if (cond != false) |
||||
Connect(conditionNode, bodyStart, ControlFlowEdgeType.ConditionTrue); |
||||
if (cond != true) |
||||
Connect(conditionNode, end, ControlFlowEdgeType.ConditionFalse); |
||||
|
||||
breakTargets.Pop(); |
||||
continueTargets.Pop(); |
||||
return end; |
||||
} |
||||
|
||||
public override ControlFlowNode VisitForStatement(ForStatement forStatement, ControlFlowNode data) |
||||
{ |
||||
data = HandleStatementList(forStatement.Initializers, data); |
||||
// for (initializers <data>; <condition>cond; <iteratorStart>iterators<iteratorEnd>) { <bodyStart> embeddedStmt; <bodyEnd> } <end>
|
||||
ControlFlowNode end = builder.CreateEndNode(forStatement); |
||||
ControlFlowNode conditionNode = builder.CreateSpecialNode(forStatement, ControlFlowNodeType.LoopCondition); |
||||
Connect(data, conditionNode); |
||||
|
||||
int iteratorStartNodeID = builder.nodes.Count; |
||||
ControlFlowNode iteratorEnd = HandleStatementList(forStatement.Iterators, null); |
||||
ControlFlowNode iteratorStart; |
||||
if (iteratorEnd != null) { |
||||
iteratorStart = builder.nodes[iteratorStartNodeID]; |
||||
Connect(iteratorEnd, conditionNode); |
||||
} else { |
||||
iteratorStart = conditionNode; |
||||
} |
||||
|
||||
breakTargets.Push(end); |
||||
continueTargets.Push(iteratorStart); |
||||
|
||||
ControlFlowNode bodyStart = builder.CreateStartNode(forStatement.EmbeddedStatement); |
||||
ControlFlowNode bodyEnd = forStatement.EmbeddedStatement.AcceptVisitor(this, bodyStart); |
||||
Connect(bodyEnd, iteratorStart); |
||||
|
||||
breakTargets.Pop(); |
||||
continueTargets.Pop(); |
||||
|
||||
bool? cond = forStatement.Condition.IsNull ? true : builder.EvaluateCondition(forStatement.Condition); |
||||
if (cond != false) |
||||
Connect(conditionNode, bodyStart, ControlFlowEdgeType.ConditionTrue); |
||||
if (cond != true) |
||||
Connect(conditionNode, end, ControlFlowEdgeType.ConditionFalse); |
||||
|
||||
return end; |
||||
} |
||||
|
||||
ControlFlowNode HandleEmbeddedStatement(Statement embeddedStatement, ControlFlowNode source) |
||||
{ |
||||
if (embeddedStatement == null || embeddedStatement.IsNull) |
||||
return source; |
||||
ControlFlowNode bodyStart = builder.CreateStartNode(embeddedStatement); |
||||
if (source != null) |
||||
Connect(source, bodyStart); |
||||
return embeddedStatement.AcceptVisitor(this, bodyStart); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitForeachStatement(ForeachStatement foreachStatement, ControlFlowNode data) |
||||
{ |
||||
// <data> foreach (<condition>...) { <bodyStart>embeddedStmt<bodyEnd> } <end>
|
||||
ControlFlowNode end = builder.CreateEndNode(foreachStatement); |
||||
ControlFlowNode conditionNode = builder.CreateSpecialNode(foreachStatement, ControlFlowNodeType.LoopCondition); |
||||
Connect(data, conditionNode); |
||||
|
||||
breakTargets.Push(end); |
||||
continueTargets.Push(conditionNode); |
||||
|
||||
ControlFlowNode bodyEnd = HandleEmbeddedStatement(foreachStatement.EmbeddedStatement, conditionNode); |
||||
Connect(bodyEnd, conditionNode); |
||||
|
||||
breakTargets.Pop(); |
||||
continueTargets.Pop(); |
||||
|
||||
Connect(conditionNode, end); |
||||
|
||||
return end; |
||||
} |
||||
|
||||
public override ControlFlowNode VisitBreakStatement(BreakStatement breakStatement, ControlFlowNode data) |
||||
{ |
||||
if (breakTargets.Count > 0) |
||||
Connect(data, breakTargets.Peek(), ControlFlowEdgeType.Jump); |
||||
return builder.CreateEndNode(breakStatement); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitContinueStatement(ContinueStatement continueStatement, ControlFlowNode data) |
||||
{ |
||||
if (continueTargets.Count > 0) |
||||
Connect(data, continueTargets.Peek(), ControlFlowEdgeType.Jump); |
||||
return builder.CreateEndNode(continueStatement); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitGotoStatement(GotoStatement gotoStatement, ControlFlowNode data) |
||||
{ |
||||
builder.gotoStatements.Add(data); |
||||
return builder.CreateEndNode(gotoStatement); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitReturnStatement(ReturnStatement returnStatement, ControlFlowNode data) |
||||
{ |
||||
return builder.CreateEndNode(returnStatement); // end not connected with data
|
||||
} |
||||
|
||||
public override ControlFlowNode VisitThrowStatement(ThrowStatement throwStatement, ControlFlowNode data) |
||||
{ |
||||
return builder.CreateEndNode(throwStatement); // end not connected with data
|
||||
} |
||||
|
||||
public override ControlFlowNode VisitTryCatchStatement(TryCatchStatement tryCatchStatement, ControlFlowNode data) |
||||
{ |
||||
ControlFlowNode end = builder.CreateEndNode(tryCatchStatement); |
||||
var edge = Connect(HandleEmbeddedStatement(tryCatchStatement.TryBlock, data), end); |
||||
if (!tryCatchStatement.FinallyBlock.IsNull) |
||||
edge.AddJumpOutOfTryFinally(tryCatchStatement); |
||||
foreach (CatchClause cc in tryCatchStatement.CatchClauses) { |
||||
edge = Connect(HandleEmbeddedStatement(cc.Body, data), end); |
||||
if (!tryCatchStatement.FinallyBlock.IsNull) |
||||
edge.AddJumpOutOfTryFinally(tryCatchStatement); |
||||
} |
||||
if (!tryCatchStatement.FinallyBlock.IsNull) { |
||||
// Don't connect the end of the try-finally block to anything.
|
||||
// Consumers of the CFG will have to special-case try-finally.
|
||||
HandleEmbeddedStatement(tryCatchStatement.FinallyBlock, data); |
||||
} |
||||
return end; |
||||
} |
||||
|
||||
public override ControlFlowNode VisitCheckedStatement(CheckedStatement checkedStatement, ControlFlowNode data) |
||||
{ |
||||
ControlFlowNode bodyEnd = HandleEmbeddedStatement(checkedStatement.Body, data); |
||||
return CreateConnectedEndNode(checkedStatement, bodyEnd); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitUncheckedStatement(UncheckedStatement uncheckedStatement, ControlFlowNode data) |
||||
{ |
||||
ControlFlowNode bodyEnd = HandleEmbeddedStatement(uncheckedStatement.Body, data); |
||||
return CreateConnectedEndNode(uncheckedStatement, bodyEnd); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitLockStatement(LockStatement lockStatement, ControlFlowNode data) |
||||
{ |
||||
ControlFlowNode bodyEnd = HandleEmbeddedStatement(lockStatement.EmbeddedStatement, data); |
||||
return CreateConnectedEndNode(lockStatement, bodyEnd); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitUsingStatement(UsingStatement usingStatement, ControlFlowNode data) |
||||
{ |
||||
data = HandleEmbeddedStatement(usingStatement.ResourceAcquisition as Statement, data); |
||||
ControlFlowNode bodyEnd = HandleEmbeddedStatement(usingStatement.EmbeddedStatement, data); |
||||
return CreateConnectedEndNode(usingStatement, bodyEnd); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitYieldStatement(YieldStatement yieldStatement, ControlFlowNode data) |
||||
{ |
||||
return CreateConnectedEndNode(yieldStatement, data); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitYieldBreakStatement(YieldBreakStatement yieldBreakStatement, ControlFlowNode data) |
||||
{ |
||||
return builder.CreateEndNode(yieldBreakStatement); // end not connected with data
|
||||
} |
||||
|
||||
public override ControlFlowNode VisitUnsafeStatement(UnsafeStatement unsafeStatement, ControlFlowNode data) |
||||
{ |
||||
ControlFlowNode bodyEnd = HandleEmbeddedStatement(unsafeStatement.Body, data); |
||||
return CreateConnectedEndNode(unsafeStatement, bodyEnd); |
||||
} |
||||
|
||||
public override ControlFlowNode VisitFixedStatement(FixedStatement fixedStatement, ControlFlowNode data) |
||||
{ |
||||
ControlFlowNode bodyEnd = HandleEmbeddedStatement(fixedStatement.EmbeddedStatement, data); |
||||
return CreateConnectedEndNode(fixedStatement, bodyEnd); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,640 @@
@@ -0,0 +1,640 @@
|
||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
||||
|
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Diagnostics; |
||||
using System.Linq; |
||||
using ICSharpCode.NRefactory.CSharp.Resolver; |
||||
using ICSharpCode.NRefactory.Utils; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Analysis |
||||
{ |
||||
/// <summary>
|
||||
/// Represents the definite assignment status of a variable at a specific location.
|
||||
/// </summary>
|
||||
public enum DefiniteAssignmentStatus |
||||
{ |
||||
/// <summary>
|
||||
/// The variable might be assigned or unassigned.
|
||||
/// </summary>
|
||||
PotentiallyAssigned, |
||||
/// <summary>
|
||||
/// The variable is definitely assigned.
|
||||
/// </summary>
|
||||
DefinitelyAssigned, |
||||
/// <summary>
|
||||
/// The variable is definitely assigned iff the expression results in the value 'true'.
|
||||
/// </summary>
|
||||
AssignedAfterTrueExpression, |
||||
/// <summary>
|
||||
/// The variable is definitely assigned iff the expression results in the value 'false'.
|
||||
/// </summary>
|
||||
AssignedAfterFalseExpression, |
||||
/// <summary>
|
||||
/// The code is unreachable.
|
||||
/// </summary>
|
||||
CodeUnreachable |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Implements the C# definite assignment analysis (C# 4.0 Spec: §5.3 Definite assignment)
|
||||
/// </summary>
|
||||
public class DefiniteAssignmentAnalysis |
||||
{ |
||||
readonly DefiniteAssignmentVisitor visitor = new DefiniteAssignmentVisitor(); |
||||
readonly List<ControlFlowNode> allNodes = new List<ControlFlowNode>(); |
||||
readonly Dictionary<Statement, ControlFlowNode> beginNodeDict = new Dictionary<Statement, ControlFlowNode>(); |
||||
readonly Dictionary<Statement, ControlFlowNode> endNodeDict = new Dictionary<Statement, ControlFlowNode>(); |
||||
Dictionary<ControlFlowNode, DefiniteAssignmentStatus> nodeStatus = new Dictionary<ControlFlowNode, DefiniteAssignmentStatus>(); |
||||
Dictionary<ControlFlowEdge, DefiniteAssignmentStatus> edgeStatus = new Dictionary<ControlFlowEdge, DefiniteAssignmentStatus>(); |
||||
|
||||
string variableName; |
||||
List<IdentifierExpression> unassignedVariableUses = new List<IdentifierExpression>(); |
||||
|
||||
Queue<ControlFlowNode> nodesWithModifiedInput = new Queue<ControlFlowNode>(); |
||||
|
||||
public DefiniteAssignmentAnalysis(Statement rootStatement) |
||||
{ |
||||
visitor.analysis = this; |
||||
ControlFlowGraphBuilder b = new ControlFlowGraphBuilder(); |
||||
allNodes.AddRange(b.BuildControlFlowGraph(rootStatement)); |
||||
foreach (AstNode descendant in rootStatement.Descendants) { |
||||
// Anonymous methods have separate control flow graphs, but we also need to analyze those.
|
||||
AnonymousMethodExpression ame = descendant as AnonymousMethodExpression; |
||||
if (ame != null) |
||||
allNodes.AddRange(b.BuildControlFlowGraph(ame.Body)); |
||||
LambdaExpression lambda = descendant as LambdaExpression; |
||||
if (lambda != null && lambda.Body is Statement) |
||||
allNodes.AddRange(b.BuildControlFlowGraph((Statement)lambda.Body)); |
||||
} |
||||
// Verify that we created nodes for all statements:
|
||||
Debug.Assert(!rootStatement.DescendantsAndSelf.OfType<Statement>().Except(allNodes.Select(n => n.NextStatement)).Any()); |
||||
// Now register the nodes in the dictionaries:
|
||||
foreach (ControlFlowNode node in allNodes) { |
||||
if (node.Type == ControlFlowNodeType.StartNode || node.Type == ControlFlowNodeType.BetweenStatements) |
||||
beginNodeDict.Add(node.NextStatement, node); |
||||
if (node.Type == ControlFlowNodeType.BetweenStatements || node.Type == ControlFlowNodeType.EndNode) |
||||
endNodeDict.Add(node.PreviousStatement, node); |
||||
} |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Gets the unassigned usages of the previously analyzed variable.
|
||||
/// </summary>
|
||||
public IList<IdentifierExpression> UnassignedVariableUses { |
||||
get { |
||||
return unassignedVariableUses.AsReadOnly(); |
||||
} |
||||
} |
||||
|
||||
public void Analyze(string variable, DefiniteAssignmentStatus initialStatus = DefiniteAssignmentStatus.PotentiallyAssigned) |
||||
{ |
||||
this.variableName = variable; |
||||
// Reset the status:
|
||||
unassignedVariableUses.Clear(); |
||||
foreach (ControlFlowNode node in allNodes) { |
||||
nodeStatus[node] = DefiniteAssignmentStatus.CodeUnreachable; |
||||
foreach (ControlFlowEdge edge in node.Outgoing) |
||||
edgeStatus[edge] = DefiniteAssignmentStatus.CodeUnreachable; |
||||
} |
||||
|
||||
ChangeNodeStatus(allNodes[0], initialStatus); |
||||
// Iterate as long as the input status of some nodes is changing:
|
||||
while (nodesWithModifiedInput.Count > 0) { |
||||
ControlFlowNode node = nodesWithModifiedInput.Dequeue(); |
||||
DefiniteAssignmentStatus inputStatus = DefiniteAssignmentStatus.CodeUnreachable; |
||||
foreach (ControlFlowEdge edge in node.Incoming) { |
||||
inputStatus = MergeStatus(inputStatus, edgeStatus[edge]); |
||||
} |
||||
ChangeNodeStatus(node, inputStatus); |
||||
} |
||||
} |
||||
|
||||
public DefiniteAssignmentStatus GetStatusBefore(Statement statement) |
||||
{ |
||||
return nodeStatus[beginNodeDict[statement]]; |
||||
} |
||||
|
||||
public DefiniteAssignmentStatus GetStatusAfter(Statement statement) |
||||
{ |
||||
return nodeStatus[endNodeDict[statement]]; |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Exports the CFG. This method is intended to help debugging issues related to definite assignment.
|
||||
/// </summary>
|
||||
public GraphVizGraph ExportGraph() |
||||
{ |
||||
GraphVizGraph g = new GraphVizGraph(); |
||||
g.Title = "DefiniteAssignment - " + variableName; |
||||
for (int i = 0; i < allNodes.Count; i++) { |
||||
string name = nodeStatus[allNodes[i]].ToString() + Environment.NewLine; |
||||
switch (allNodes[i].Type) { |
||||
case ControlFlowNodeType.StartNode: |
||||
case ControlFlowNodeType.BetweenStatements: |
||||
name += allNodes[i].NextStatement.ToString(); |
||||
break; |
||||
case ControlFlowNodeType.EndNode: |
||||
name += "End of " + allNodes[i].PreviousStatement.ToString(); |
||||
break; |
||||
case ControlFlowNodeType.LoopCondition: |
||||
name += "Condition in " + allNodes[i].NextStatement.ToString(); |
||||
break; |
||||
default: |
||||
name += allNodes[i].Type.ToString(); |
||||
break; |
||||
} |
||||
g.AddNode(new GraphVizNode(i) { label = name }); |
||||
foreach (ControlFlowEdge edge in allNodes[i].Outgoing) { |
||||
GraphVizEdge ge = new GraphVizEdge(i, allNodes.IndexOf(edge.To)); |
||||
if (edgeStatus.Count > 0) |
||||
ge.label = edgeStatus[edge].ToString(); |
||||
if (edge.IsLeavingTryFinally) |
||||
ge.style = "dashed"; |
||||
switch (edge.Type) { |
||||
case ControlFlowEdgeType.ConditionTrue: |
||||
ge.color = "green"; |
||||
break; |
||||
case ControlFlowEdgeType.ConditionFalse: |
||||
ge.color = "red"; |
||||
break; |
||||
case ControlFlowEdgeType.Jump: |
||||
ge.color = "blue"; |
||||
break; |
||||
} |
||||
g.AddEdge(ge); |
||||
} |
||||
} |
||||
return g; |
||||
} |
||||
|
||||
static DefiniteAssignmentStatus MergeStatus(DefiniteAssignmentStatus a, DefiniteAssignmentStatus b) |
||||
{ |
||||
// The result will be DefinitelyAssigned if at least one incoming edge is DefinitelyAssigned and all others are unreachable.
|
||||
// The result will be DefinitelyUnassigned if at least one incoming edge is DefinitelyUnassigned and all others are unreachable.
|
||||
// The result will be Unreachable if all incoming edges are unreachable.
|
||||
// Otherwise, the result will be PotentiallyAssigned.
|
||||
|
||||
if (a == b) |
||||
return a; |
||||
else if (a == DefiniteAssignmentStatus.CodeUnreachable) |
||||
return b; |
||||
else if (b == DefiniteAssignmentStatus.CodeUnreachable) |
||||
return a; |
||||
else |
||||
return DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
} |
||||
|
||||
void ChangeNodeStatus(ControlFlowNode node, DefiniteAssignmentStatus inputStatus) |
||||
{ |
||||
if (nodeStatus[node] == inputStatus) |
||||
return; |
||||
nodeStatus[node] = inputStatus; |
||||
DefiniteAssignmentStatus outputStatus; |
||||
switch (node.Type) { |
||||
case ControlFlowNodeType.StartNode: |
||||
case ControlFlowNodeType.BetweenStatements: |
||||
if (node.NextStatement is IfElseStatement) { |
||||
// Handle if-else as a condition node
|
||||
goto case ControlFlowNodeType.LoopCondition; |
||||
} |
||||
if (inputStatus == DefiniteAssignmentStatus.DefinitelyAssigned) { |
||||
// There isn't any way to un-assign variables, so we don't have to check the expression
|
||||
// if the status already is definitely assigned.
|
||||
outputStatus = DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
} else { |
||||
outputStatus = CleanSpecialValues(node.NextStatement.AcceptVisitor(visitor, inputStatus)); |
||||
} |
||||
break; |
||||
case ControlFlowNodeType.EndNode: |
||||
outputStatus = inputStatus; |
||||
if (node.PreviousStatement.Role == TryCatchStatement.FinallyBlockRole |
||||
&& (outputStatus == DefiniteAssignmentStatus.DefinitelyAssigned || outputStatus == DefiniteAssignmentStatus.PotentiallyAssigned)) |
||||
{ |
||||
TryCatchStatement tryFinally = (TryCatchStatement)node.PreviousStatement.Parent; |
||||
// Changing the status on a finally block potentially changes the status of all edges leaving that finally block:
|
||||
foreach (ControlFlowEdge edge in allNodes.SelectMany(n => n.Outgoing)) { |
||||
if (edge.IsLeavingTryFinally && edge.TryFinallyStatements.Contains(tryFinally)) { |
||||
DefiniteAssignmentStatus s = edgeStatus[edge]; |
||||
if (s == DefiniteAssignmentStatus.PotentiallyAssigned) { |
||||
ChangeEdgeStatus(edge, outputStatus); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
break; |
||||
case ControlFlowNodeType.LoopCondition: |
||||
ForeachStatement foreachStmt = node.NextStatement as ForeachStatement; |
||||
if (foreachStmt != null) { |
||||
outputStatus = CleanSpecialValues(foreachStmt.InExpression.AcceptVisitor(visitor, inputStatus)); |
||||
if (foreachStmt.VariableName == this.variableName) |
||||
outputStatus = DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
break; |
||||
} else { |
||||
Debug.Assert(node.NextStatement is IfElseStatement || node.NextStatement is WhileStatement || node.NextStatement is ForStatement || node.NextStatement is DoWhileStatement); |
||||
Expression condition = node.NextStatement.GetChildByRole(AstNode.Roles.Condition); |
||||
if (condition.IsNull) |
||||
outputStatus = inputStatus; |
||||
else |
||||
outputStatus = condition.AcceptVisitor(visitor, inputStatus); |
||||
foreach (ControlFlowEdge edge in node.Outgoing) { |
||||
if (edge.Type == ControlFlowEdgeType.ConditionTrue && outputStatus == DefiniteAssignmentStatus.AssignedAfterTrueExpression) { |
||||
ChangeEdgeStatus(edge, DefiniteAssignmentStatus.DefinitelyAssigned); |
||||
} else if (edge.Type == ControlFlowEdgeType.ConditionFalse && outputStatus == DefiniteAssignmentStatus.AssignedAfterFalseExpression) { |
||||
ChangeEdgeStatus(edge, DefiniteAssignmentStatus.DefinitelyAssigned); |
||||
} else { |
||||
ChangeEdgeStatus(edge, CleanSpecialValues(outputStatus)); |
||||
} |
||||
} |
||||
return; |
||||
} |
||||
default: |
||||
throw new InvalidOperationException(); |
||||
} |
||||
foreach (ControlFlowEdge edge in node.Outgoing) { |
||||
ChangeEdgeStatus(edge, outputStatus); |
||||
} |
||||
} |
||||
|
||||
void ChangeEdgeStatus(ControlFlowEdge edge, DefiniteAssignmentStatus newStatus) |
||||
{ |
||||
DefiniteAssignmentStatus oldStatus = edgeStatus[edge]; |
||||
if (oldStatus == newStatus) |
||||
return; |
||||
// Ensure that status can change only in one direction:
|
||||
// CodeUnreachable -> PotentiallyAssigned -> DefinitelyAssigned
|
||||
// Going against this direction indicates a bug and could cause infinite loops.
|
||||
switch (oldStatus) { |
||||
case DefiniteAssignmentStatus.PotentiallyAssigned: |
||||
if (newStatus != DefiniteAssignmentStatus.DefinitelyAssigned) |
||||
throw new InvalidOperationException("Invalid state transition"); |
||||
break; |
||||
case DefiniteAssignmentStatus.CodeUnreachable: |
||||
if (!(newStatus == DefiniteAssignmentStatus.PotentiallyAssigned || newStatus == DefiniteAssignmentStatus.DefinitelyAssigned)) |
||||
throw new InvalidOperationException("Invalid state transition"); |
||||
break; |
||||
case DefiniteAssignmentStatus.DefinitelyAssigned: |
||||
throw new InvalidOperationException("Invalid state transition"); |
||||
default: |
||||
throw new InvalidOperationException("Invalid value for DefiniteAssignmentStatus"); |
||||
} |
||||
edgeStatus[edge] = newStatus; |
||||
nodesWithModifiedInput.Enqueue(edge.To); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Evaluates an expression.
|
||||
/// </summary>
|
||||
/// <returns>The constant value of the expression; or null if the expression is not a constant.</returns>
|
||||
ConstantResolveResult EvaluateConstant(Expression expr) |
||||
{ |
||||
return null; // TODO: implement this using the C# resolver
|
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Evaluates an expression.
|
||||
/// </summary>
|
||||
/// <returns>The value of the constant boolean expression; or null if the value is not a constant boolean expression.</returns>
|
||||
bool? EvaluateCondition(Expression expr) |
||||
{ |
||||
ConstantResolveResult crr = EvaluateConstant(expr); |
||||
if (crr != null) |
||||
return crr.ConstantValue as bool?; |
||||
else |
||||
return null; |
||||
} |
||||
|
||||
static DefiniteAssignmentStatus CleanSpecialValues(DefiniteAssignmentStatus status) |
||||
{ |
||||
if (status == DefiniteAssignmentStatus.AssignedAfterTrueExpression) |
||||
return DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
else if (status == DefiniteAssignmentStatus.AssignedAfterFalseExpression) |
||||
return DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
else |
||||
return status; |
||||
} |
||||
|
||||
sealed class DefiniteAssignmentVisitor : DepthFirstAstVisitor<DefiniteAssignmentStatus, DefiniteAssignmentStatus> |
||||
{ |
||||
internal DefiniteAssignmentAnalysis analysis; |
||||
|
||||
// The general approach for unknown nodes is to pass the status through all child nodes in order
|
||||
protected override DefiniteAssignmentStatus VisitChildren(AstNode node, DefiniteAssignmentStatus data) |
||||
{ |
||||
// the special values are valid as output only, not as input
|
||||
Debug.Assert(data == CleanSpecialValues(data)); |
||||
DefiniteAssignmentStatus status = data; |
||||
foreach (AstNode child in node.Children) { |
||||
Debug.Assert(!(child is Statement)); // statements are visited with the CFG, not with the visitor pattern
|
||||
status = child.AcceptVisitor(this, status); |
||||
status = CleanSpecialValues(status); |
||||
} |
||||
return status; |
||||
} |
||||
|
||||
#region Statements
|
||||
// For statements, the visitor only describes the effect of the statement itself;
|
||||
// we do not consider the effect of any nested statements.
|
||||
// This is done because the nested statements will be reached using the control flow graph.
|
||||
|
||||
// In fact, these methods are present so that the default logic in VisitChildren does not try to visit the nested statements.
|
||||
|
||||
public override DefiniteAssignmentStatus VisitBlockStatement(BlockStatement blockStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitCheckedStatement(CheckedStatement checkedStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitUncheckedStatement(UncheckedStatement uncheckedStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; |
||||
} |
||||
|
||||
// ExpressionStatement handled by default logic
|
||||
// VariableDeclarationStatement handled by default logic
|
||||
|
||||
public override DefiniteAssignmentStatus VisitVariableInitializer(VariableInitializer variableInitializer, DefiniteAssignmentStatus data) |
||||
{ |
||||
if (variableInitializer.Initializer.IsNull) { |
||||
return data; |
||||
} else { |
||||
DefiniteAssignmentStatus status = variableInitializer.Initializer.AcceptVisitor(this, data); |
||||
if (variableInitializer.Name == analysis.variableName) |
||||
return DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
else |
||||
return status; |
||||
} |
||||
} |
||||
|
||||
// IfStatement not handled by visitor, but special-cased in the code consuming the control flow graph
|
||||
|
||||
public override DefiniteAssignmentStatus VisitSwitchStatement(SwitchStatement switchStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return switchStatement.Expression.AcceptVisitor(this, data); |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitWhileStatement(WhileStatement whileStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; // condition is handled by special condition CFG node
|
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitDoWhileStatement(DoWhileStatement doWhileStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; // condition is handled by special condition CFG node
|
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitForStatement(ForStatement forStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; // condition is handled by special condition CFG node; initializer and iterator statements are handled by CFG
|
||||
} |
||||
|
||||
// Break/Continue/Goto: handled by default logic
|
||||
|
||||
// ThrowStatement: handled by default logic (just visit the expression)
|
||||
// ReturnStatement: handled by default logic (just visit the expression)
|
||||
|
||||
public override DefiniteAssignmentStatus VisitTryCatchStatement(TryCatchStatement tryCatchStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; // no special logic when entering the try-catch-finally statement
|
||||
// TODO: where to put the special logic when exiting the try-finally statement?
|
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitForeachStatement(ForeachStatement foreachStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; // assignment of the foreach loop variable is done when handling the condition node
|
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitUsingStatement(UsingStatement usingStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
if (usingStatement.ResourceAcquisition is Expression) |
||||
return usingStatement.ResourceAcquisition.AcceptVisitor(this, data); |
||||
else |
||||
return data; // don't handle resource acquisition statements, as those are connected in the control flow graph
|
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitLockStatement(LockStatement lockStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return lockStatement.Expression.AcceptVisitor(this, data); |
||||
} |
||||
|
||||
// Yield statements use the default logic
|
||||
|
||||
public override DefiniteAssignmentStatus VisitUnsafeStatement(UnsafeStatement unsafeStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
return data; |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitFixedStatement(FixedStatement fixedStatement, DefiniteAssignmentStatus data) |
||||
{ |
||||
DefiniteAssignmentStatus status = data; |
||||
foreach (var variable in fixedStatement.Variables) |
||||
status = variable.AcceptVisitor(this, status); |
||||
return status; |
||||
} |
||||
#endregion
|
||||
|
||||
public override DefiniteAssignmentStatus VisitDirectionExpression(DirectionExpression directionExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
if (directionExpression.FieldDirection == FieldDirection.Out) { |
||||
return HandleAssignment(directionExpression.Expression, null, data); |
||||
} else { |
||||
// use default logic for 'ref'
|
||||
return VisitChildren(directionExpression, data); |
||||
} |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitAssignmentExpression(AssignmentExpression assignmentExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
if (assignmentExpression.Operator == AssignmentOperatorType.Assign) { |
||||
return HandleAssignment(assignmentExpression.Left, assignmentExpression.Right, data); |
||||
} else { |
||||
// use default logic for compound assignment operators
|
||||
return VisitChildren(assignmentExpression, data); |
||||
} |
||||
} |
||||
|
||||
DefiniteAssignmentStatus HandleAssignment(Expression left, Expression right, DefiniteAssignmentStatus initialStatus) |
||||
{ |
||||
IdentifierExpression ident = left as IdentifierExpression; |
||||
if (ident != null && ident.Identifier == analysis.variableName) { |
||||
right.AcceptVisitor(this, initialStatus); |
||||
return DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
} else { |
||||
DefiniteAssignmentStatus status = left.AcceptVisitor(this, initialStatus); |
||||
status = right.AcceptVisitor(this, CleanSpecialValues(status)); |
||||
return CleanSpecialValues(status); |
||||
} |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
// Don't use the default logic here because we don't want to clean up the special values.
|
||||
return parenthesizedExpression.Expression.AcceptVisitor(this, data); |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitCheckedExpression(CheckedExpression checkedExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
return checkedExpression.Expression.AcceptVisitor(this, data); |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitUncheckedExpression(UncheckedExpression uncheckedExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
return uncheckedExpression.Expression.AcceptVisitor(this, data); |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
if (binaryOperatorExpression.Operator == BinaryOperatorType.ConditionalAnd) { |
||||
// Handle constant left side of && expressions (not in the C# spec, but done by the MS compiler)
|
||||
bool? cond = analysis.EvaluateCondition(binaryOperatorExpression.Left); |
||||
if (cond == true) |
||||
return binaryOperatorExpression.Right.AcceptVisitor(this, data); // right operand gets evaluated unconditionally
|
||||
else if (cond == false) |
||||
return data; // right operand never gets evaluated
|
||||
// C# 4.0 spec: §5.3.3.24 Definite Assignment for && expressions
|
||||
DefiniteAssignmentStatus afterLeft = binaryOperatorExpression.Left.AcceptVisitor(this, data); |
||||
DefiniteAssignmentStatus beforeRight; |
||||
if (afterLeft == DefiniteAssignmentStatus.AssignedAfterTrueExpression) |
||||
beforeRight = DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
else if (afterLeft == DefiniteAssignmentStatus.AssignedAfterFalseExpression) |
||||
beforeRight = DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
else |
||||
beforeRight = afterLeft; |
||||
DefiniteAssignmentStatus afterRight = binaryOperatorExpression.Right.AcceptVisitor(this, beforeRight); |
||||
if (afterLeft == DefiniteAssignmentStatus.DefinitelyAssigned) |
||||
return DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
else if (afterRight == DefiniteAssignmentStatus.DefinitelyAssigned && afterLeft == DefiniteAssignmentStatus.AssignedAfterFalseExpression) |
||||
return DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
else if (afterRight == DefiniteAssignmentStatus.DefinitelyAssigned || afterRight == DefiniteAssignmentStatus.AssignedAfterTrueExpression) |
||||
return DefiniteAssignmentStatus.AssignedAfterTrueExpression; |
||||
else if (afterLeft == DefiniteAssignmentStatus.AssignedAfterFalseExpression && afterRight == DefiniteAssignmentStatus.AssignedAfterFalseExpression) |
||||
return DefiniteAssignmentStatus.AssignedAfterFalseExpression; |
||||
else |
||||
return DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
} else if (binaryOperatorExpression.Operator == BinaryOperatorType.ConditionalOr) { |
||||
// C# 4.0 spec: §5.3.3.25 Definite Assignment for || expressions
|
||||
bool? cond = analysis.EvaluateCondition(binaryOperatorExpression.Left); |
||||
if (cond == false) |
||||
return binaryOperatorExpression.Right.AcceptVisitor(this, data); // right operand gets evaluated unconditionally
|
||||
else if (cond == true) |
||||
return data; // right operand never gets evaluated
|
||||
DefiniteAssignmentStatus afterLeft = binaryOperatorExpression.Left.AcceptVisitor(this, data); |
||||
DefiniteAssignmentStatus beforeRight; |
||||
if (afterLeft == DefiniteAssignmentStatus.AssignedAfterTrueExpression) |
||||
beforeRight = DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
else if (afterLeft == DefiniteAssignmentStatus.AssignedAfterFalseExpression) |
||||
beforeRight = DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
else |
||||
beforeRight = afterLeft; |
||||
DefiniteAssignmentStatus afterRight = binaryOperatorExpression.Right.AcceptVisitor(this, beforeRight); |
||||
if (afterLeft == DefiniteAssignmentStatus.DefinitelyAssigned) |
||||
return DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
else if (afterRight == DefiniteAssignmentStatus.DefinitelyAssigned && afterLeft == DefiniteAssignmentStatus.AssignedAfterTrueExpression) |
||||
return DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
else if (afterRight == DefiniteAssignmentStatus.DefinitelyAssigned || afterRight == DefiniteAssignmentStatus.AssignedAfterFalseExpression) |
||||
return DefiniteAssignmentStatus.AssignedAfterFalseExpression; |
||||
else if (afterLeft == DefiniteAssignmentStatus.AssignedAfterTrueExpression && afterRight == DefiniteAssignmentStatus.AssignedAfterTrueExpression) |
||||
return DefiniteAssignmentStatus.AssignedAfterTrueExpression; |
||||
else |
||||
return DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
} else if (binaryOperatorExpression.Operator == BinaryOperatorType.NullCoalescing) { |
||||
// C# 4.0 spec: §5.3.3.27 Definite assignment for ?? expressions
|
||||
ConstantResolveResult crr = analysis.EvaluateConstant(binaryOperatorExpression.Left); |
||||
if (crr != null && crr.ConstantValue == null) |
||||
return binaryOperatorExpression.Right.AcceptVisitor(this, data); |
||||
DefiniteAssignmentStatus status = CleanSpecialValues(binaryOperatorExpression.Left.AcceptVisitor(this, data)); |
||||
binaryOperatorExpression.Right.AcceptVisitor(this, status); |
||||
return status; |
||||
} else { |
||||
// use default logic for other operators
|
||||
return VisitChildren(binaryOperatorExpression, data); |
||||
} |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
if (unaryOperatorExpression.Operator == UnaryOperatorType.Not) { |
||||
// C# 4.0 spec: §5.3.3.26 Definite assignment for ! expressions
|
||||
DefiniteAssignmentStatus status = unaryOperatorExpression.Expression.AcceptVisitor(this, data); |
||||
if (status == DefiniteAssignmentStatus.AssignedAfterFalseExpression) |
||||
return DefiniteAssignmentStatus.AssignedAfterTrueExpression; |
||||
else if (status == DefiniteAssignmentStatus.AssignedAfterTrueExpression) |
||||
return DefiniteAssignmentStatus.AssignedAfterFalseExpression; |
||||
else |
||||
return status; |
||||
} else { |
||||
// use default logic for other operators
|
||||
return VisitChildren(unaryOperatorExpression, data); |
||||
} |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitConditionalExpression(ConditionalExpression conditionalExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
// C# 4.0 spec: §5.3.3.28 Definite assignment for ?: expressions
|
||||
bool? cond = analysis.EvaluateCondition(conditionalExpression.Condition); |
||||
if (cond == true) { |
||||
return conditionalExpression.TrueExpression.AcceptVisitor(this, data); |
||||
} else if (cond == false) { |
||||
return conditionalExpression.FalseExpression.AcceptVisitor(this, data); |
||||
} else { |
||||
DefiniteAssignmentStatus afterCondition = conditionalExpression.Condition.AcceptVisitor(this, data); |
||||
|
||||
DefiniteAssignmentStatus beforeTrue, beforeFalse; |
||||
if (afterCondition == DefiniteAssignmentStatus.AssignedAfterTrueExpression) { |
||||
beforeTrue = DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
beforeFalse = DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
} else if (afterCondition == DefiniteAssignmentStatus.AssignedAfterFalseExpression) { |
||||
beforeTrue = DefiniteAssignmentStatus.PotentiallyAssigned; |
||||
beforeFalse = DefiniteAssignmentStatus.DefinitelyAssigned; |
||||
} else { |
||||
beforeTrue = afterCondition; |
||||
beforeFalse = afterCondition; |
||||
} |
||||
|
||||
DefiniteAssignmentStatus afterTrue = conditionalExpression.TrueExpression.AcceptVisitor(this, beforeTrue); |
||||
DefiniteAssignmentStatus afterFalse = conditionalExpression.TrueExpression.AcceptVisitor(this, beforeFalse); |
||||
return MergeStatus(CleanSpecialValues(afterTrue), CleanSpecialValues(afterFalse)); |
||||
} |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
BlockStatement body = anonymousMethodExpression.Body; |
||||
foreach (ControlFlowNode node in analysis.allNodes) { |
||||
if (node.NextStatement == body) |
||||
analysis.ChangeNodeStatus(node, data); |
||||
} |
||||
return data; |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitLambdaExpression(LambdaExpression lambdaExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
Statement body = lambdaExpression.Body as Statement; |
||||
if (body != null) { |
||||
foreach (ControlFlowNode node in analysis.allNodes) { |
||||
if (node.NextStatement == body) |
||||
analysis.ChangeNodeStatus(node, data); |
||||
} |
||||
} else { |
||||
lambdaExpression.Body.AcceptVisitor(this, data); |
||||
} |
||||
return data; |
||||
} |
||||
|
||||
public override DefiniteAssignmentStatus VisitIdentifierExpression(IdentifierExpression identifierExpression, DefiniteAssignmentStatus data) |
||||
{ |
||||
if (data != DefiniteAssignmentStatus.DefinitelyAssigned |
||||
&& identifierExpression.Identifier == analysis.variableName && identifierExpression.TypeArguments.Count == 0) |
||||
{ |
||||
analysis.unassignedVariableUses.Add(identifierExpression); |
||||
} |
||||
return data; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue