private List<int> GetStatementsToInline(StatementCollection statements)
{
List<int> result = new List<int>();
BlockStatement parent = (BlockStatement)statements[0].Parent;
if (parent == null)
{
throw new NullReferenceException("parent");
}
foreach (KeyValuePair<VariableDefinition, DefineUseCount> pair in patternsContext.VariableToDefineUseCountContext)
{
if (pair.Value.DefineCount != 1 || pair.Value.UseCount != 1)
{
continue;
}
ExpressionStatement defineExpression = patternsContext.VariableToSingleAssignmentMap[pair.Key];
if (defineExpression.Parent != parent)
{
continue;
}
int index = statements.IndexOf(defineExpression);
if (index == -1)
{
throw new IndexOutOfRangeException("index");
}
result.Add(index);
}
result.Sort();
return result;
}
private bool Match(StatementCollection statements)
{
this.statements = statements;
yieldDeclaringType = GetGeneratedType();
if (yieldDeclaringType == null)
{
return false;
}
IEnumerable<Statement> moveNextMethodStatements = GetStatements();
if (moveNextMethodStatements == null || yieldData == null)
{
return false;
}
if (statements.Count > 2)
{
SetParameterMappings();
StatementCollection getEnumeratorStatements = GetEnumeratorStatements();
if (getEnumeratorStatements != null)
{
PostProcessMappings(getEnumeratorStatements);
}
}
newStatements = new StatementCollection();
foreach (Statement statement in moveNextMethodStatements)
{
newStatements.Add(statement);
}
return true;
}
private StatementCollection GetStatementsForInvocation(out int endIndex, out int startIndex, out bool isBaseCtor)
{
startIndex = 0;
StatementCollection bodyStatements = methodBodyBlock.Statements;
StatementCollection statements = new StatementCollection();
isBaseCtor = false;
int index = 0;
for (; index < bodyStatements.Count; index++)
{
if (IsVariableDeclaration(bodyStatements[index]) && statements.Count == 0)
{
startIndex++;
continue;
}
statements.Add(bodyStatements[index].Clone());
if (IsCtorInvocation(bodyStatements[index], out isBaseCtor))
{
if (isBaseCtor)
{
methodContext.IsBaseConstructorInvokingConstructor = true;
}
break;
}
}
endIndex = index;
if (index == bodyStatements.Count)
{
endIndex = -1;
statements = null;
}
return statements;
}
private bool Match()
{
if (this.originalStatements.Count == 0)
{
return false;
}
if (!this.methodContext.Method.IsAsync(out this.stateMachineTypeDef))
{
if (!this.methodContext.Method.HasAsyncAttributes() || !IsAsyncFirstAssignmentStatement(this.originalStatements[0], out this.stateMachineTypeDef) ||
!this.methodContext.Method.HasAsyncStateMachineVariable())
{
return false;
}
}
if (!GetBuilderField())
{
return false;
}
asyncStatements = GetMoveNextStatements();
if (asyncStatements == null || !TryRemoveOuterTryCatch(asyncStatements))
{
return false;
}
SetParameterMappings(originalStatements);
matcherState = MatcherState.FindAwaitExpression;
asyncStatements = (StatementCollection)Visit(asyncStatements);
bool result = matcherState == MatcherState.FindAwaitExpression;
return result;
}
public virtual bool TryMatch(StatementCollection statements, out int startIndex, out Statement result, out int replacedStatementsCount)
{
startIndex = -1;
result = null;
replacedStatementsCount = -1;
if (statements == null || statements.Count - startIndex < 2)
{
return false;
}
for (int i = statements.Count - 1; i >= 0; i--)
{
if (TryMatchInternal(statements, i, out result, out replacedStatementsCount))
{
Expression expression = ((result as ExpressionStatement).Expression as BinaryExpression).Left;
if (expression.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
FixContext((expression as VariableReferenceExpression).Variable.Resolve(), 0, replacedStatementsCount - 1, null);
}
startIndex = i;
return true;
}
}
return false;
}
public UnsafeBlockStatement(StatementCollection statements)
{
this.Statements = statements;
foreach (Statement s in this.Statements)
{
s.Parent = this;
}
}
public HashSet<VariableDefinition> Find(StatementCollection statements)
{
ResetInternalState();
this.Visit(statements);
return this.variablesToNotInline;
}
public BlockStatement Process(DecompilationContext context, BlockStatement body)
{
this.methodContext = context.MethodContext;
this.originalStatements = body.Statements;
if (Match())
{
body.Statements = asyncStatements;
}
return body;
}
private bool Match(StatementCollection statements, int statementIndex)
{
PrepareMatcher(statements, statementIndex);
Statement currentStatement = statements[statementIndex];
if (currentStatement.CodeNodeType == CodeNodeType.TryStatement)
{
@try = currentStatement as TryStatement;
if (!DetermineWithFlagLockTypeVersion(@try))
{
return false;
}
if (this.lockType == LockType.WithFlagV2)
{
if (statementIndex - 2 < 0 || !CheckLockVariableAssignmentExpression(statements[statementIndex - 2]))
{
return false;
}
}
}
else if (currentStatement.CodeNodeType == CodeNodeType.ExpressionStatement &&
CheckTheMethodInvocation((currentStatement as ExpressionStatement).Expression as MethodInvocationExpression, "Enter"))
{
MethodReference methodReference = ((currentStatement as ExpressionStatement).Expression as MethodInvocationExpression).MethodExpression.Method;
if(methodReference.Parameters.Count != 1)
{
return false;
}
if (statementIndex + 1 >= statements.Count || statementIndex - 2 < 0)
{
return false;
}
@try = statements[statementIndex + 1] as TryStatement;
lockType = LockType.Simple;
if(!CheckTheAssignExpressions(statements[statementIndex - 2], statements[statementIndex - 1]))
{
return false;
}
lockingInstructions.AddRange(currentStatement.UnderlyingSameMethodInstructions);
}
if (@try == null)
return false;
if (!IsLockStatement(@try))
return false;
this.body = @try.Try;
return true;
}
public bool TryMatch(StatementCollection statements,out int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
startIndex = 0;
bool matched = TryMatchArrayAssignmentInternal(statements);
if (matched)
{
replacedStatementsCount = 2;
return true;
}
replacedStatementsCount = 1;
return TryMatchDirectAssignmentInternal(statements);
}
public bool TryMatch(StatementCollection statements, out int startIndex, out Statement result, out int replacedStatementsCount)
{
replacedStatementsCount = 0;
startIndex = -1;
result = null;
bool inlinedSuccessfully = false;
if(statements.Count == 0)
{
return false;
}
HashSet<VariableDefinition> markedForRemoval = new HashSet<VariableDefinition>();
List<int> positionsToInline = GetStatementsToInline(statements);
for (int i = positionsToInline.Count - 1; i >= 0; i--)
{
int index = positionsToInline[i];
ExpressionStatement defineExpression = statements[index] as ExpressionStatement;
VariableDefinition variable = ((defineExpression.Expression as BinaryExpression).Left as VariableReferenceExpression).Variable.Resolve();
if (index == statements.Count - 1 || !string.IsNullOrEmpty(defineExpression.Label))
{
markedForRemoval.Add(variable);
continue;
}
List<Instruction> instructions = new List<Instruction>(defineExpression.Expression.MappedInstructions);
instructions.AddRange((defineExpression.Expression as BinaryExpression).Left.UnderlyingSameMethodInstructions);
Expression value = (defineExpression.Expression as BinaryExpression).Right.CloneAndAttachInstructions(instructions);
ICodeNode resultNode;
if (inliner.TryInlineVariable(variable, value, statements[index + 1], ShouldInlineAggressively(variable), out resultNode))
{
statements.RemoveAt(index);
inlinedSuccessfully = true;
markedForRemoval.Add(variable);
methodContext.RemoveVariable(variable);
}
}
foreach (VariableDefinition variable in markedForRemoval)
{
patternsContext.VariableToSingleAssignmentMap.Remove(variable);
patternsContext.VariableToDefineUseCountContext.Remove(variable);
}
return inlinedSuccessfully;
}
public bool TryMatch(StatementCollection statements, out int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 2;
for (startIndex = 0; startIndex + 1 < statements.Count; startIndex++)
{
bool currentTransform = TryMatchInternal(statements, startIndex, out result);
if (currentTransform)
{
return true;
}
}
return false;
}
/// Pattern:
/// variable = Expression;
/// field = variable;
/// where
/// Expression is either array creation expression, literal constant, consturctor call from another class
/// or combination of all of the above.
private bool TryMatchArrayAssignmentInternal(StatementCollection statements)
{
if (statements.Count < 2)
{
return false;
}
ExpressionStatement theStatement = statements[0] as ExpressionStatement;
if (theStatement == null)
{
return false;
}
BinaryExpression theAssignment = theStatement.Expression as BinaryExpression;
VariableReference variable;
if (theAssignment == null || !IsAssignToVariableExpression(theAssignment, out variable))
{
return false;
}
/// A check of wheather the assigned value can be used in field declaration context could be performed.
/// At the moment, no IL samples that violate this rule were found.
Expression assignedValue = theAssignment.Right;
ExpressionStatement assignmentStatement = statements[1] as ExpressionStatement;
if (assignmentStatement == null)
{
return false;
}
Expression variableReference;
string memberFullName;
if (!IsFieldAssignment(assignmentStatement, out variableReference, out memberFullName) &&
!IsAutoPropertyAssignment(assignmentStatement, out variableReference, out memberFullName))
{
return false;
}
if (variableReference.CodeNodeType != CodeNodeType.VariableReferenceExpression ||
(variableReference as VariableReferenceExpression).Variable != variable)
{
return false;
}
/// The simple name of the field can be used here as well.
/// Using the full name for consistency with other maps.
return MapAssignmentIntoContext(memberFullName, assignedValue);
}
private bool ProcessStatementCollection(StatementCollection statements, IEnumerable<ICodePattern> patternInvokeArray)
{
for (int i = 0; i < statements.Count; i++)
{
if (statements[i].CodeNodeType == CodeNodeType.IfStatement)
{
IfStatement theIf = statements[i] as IfStatement;
ProcessStatementCollection(theIf.Then.Statements, patternInvokeArray);
if (theIf.Else != null)
{
ProcessStatementCollection(theIf.Else.Statements, patternInvokeArray);
}
}
}
bool didTransform;
do
{
didTransform = false;
foreach (ICodePattern pattern in patternInvokeArray)
{
int replacedStatementsCount = -1;
Statement resultingStatement;
int startIndex;
bool currentTransformation = pattern.TryMatch(statements, out startIndex, out resultingStatement, out replacedStatementsCount);
didTransform |= currentTransformation;
if (currentTransformation)
{
if (resultingStatement != null)
{
RemoveRangeAndInsert(statements, startIndex, replacedStatementsCount, resultingStatement);
}
else
{
RemoveRange(statements, startIndex, replacedStatementsCount);
}
break;
}
}
} while (didTransform);
return statements.Count == 1;
}
public void TestNonSignificantWhitespaceRegions1()
{
Boo.Lang.Compiler.Ast.Module module = ParseTestCase("nonsignificant_ws_regions_1.boo");
StatementCollection stmts = module.Globals.Statements;
Assert.AreEqual(2, stmts.Count);
ExpressionStatement es = (ExpressionStatement)stmts[0];
BinaryExpression ae = (BinaryExpression)es.Expression;
Assert.AreEqual(BinaryOperatorType.Assign, ae.Operator);
Assert.AreEqual("a", ((ReferenceExpression)ae.Left).Name);
Assert.AreEqual(2, ((ListLiteralExpression)ae.Right).Items.Count);
ForStatement fs = (ForStatement)stmts[1];
MethodInvocationExpression mce = (MethodInvocationExpression)fs.Iterator;
Assert.AreEqual("map", ((ReferenceExpression)mce.Target).Name);
Assert.AreEqual(2, mce.Arguments.Count);
Assert.AreEqual(1, fs.Block.Statements.Count);
}
private bool TryGetAssignment(StatementCollection statements, int startIndex, out BinaryExpression binaryExpression)
{
binaryExpression = null;
var statement = statements[startIndex];
if (statement.CodeNodeType != CodeNodeType.ExpressionStatement)
{
return(false);
}
Expression firstExpression = (statement as ExpressionStatement).Expression;
if (firstExpression.CodeNodeType != CodeNodeType.BinaryExpression)
{
return(false);
}
var result = firstExpression as BinaryExpression;
if (!result.IsAssignmentExpression)
{
return(false);
}
if (!(result.Left.CodeNodeType == CodeNodeType.VariableReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.VariableDeclarationExpression ||
result.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.ThisReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.PropertyReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.ArgumentReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.UnaryExpression && (result.Left as UnaryExpression).Operand.CodeNodeType == CodeNodeType.ArgumentReferenceExpression))
{
return(false);
}
binaryExpression = result;
return(true);
}
private StatementCollection GetStatementsForInvocation(out int endIndex, out int startIndex, out bool isBaseCtor)
{
startIndex = 0;
StatementCollection bodyStatements = methodBodyBlock.Statements;
StatementCollection statements = new StatementCollection();
isBaseCtor = false;
int index = 0;
for (; index < bodyStatements.Count; index++)
{
if (IsVariableDeclaration(bodyStatements[index]) && statements.Count == 0)
{
startIndex++;
continue;
}
statements.Add(bodyStatements[index].Clone());
if (IsCtorInvocation(bodyStatements[index], out isBaseCtor))
{
if (isBaseCtor)
{
methodContext.IsBaseConstructorInvokingConstructor = true;
}
break;
}
}
endIndex = index;
if (index == bodyStatements.Count)
{
endIndex = -1;
statements = null;
}
return(statements);
}
/// Pattern:
/// field = Expression;
/// where
/// Expression is either array creation expression, literal constant, consturctor call from another class
/// or combination of all of the above.
private bool TryMatchDirectAssignmentInternal(StatementCollection statements)
{
ExpressionStatement theStatement = statements[0] as ExpressionStatement;
if (theStatement == null || !string.IsNullOrEmpty(statements[0].Label))
{
return(false);
}
string memberFullName;
Expression assignedValue;
if (!IsFieldAssignment(theStatement, out assignedValue, out memberFullName) &&
!IsAutoPropertyAssignment(theStatement, out assignedValue, out memberFullName))
{
return(false);
}
/// A check of wheather the assigned value can be used in field declaration context could be performed.
/// At the moment, no IL samples that violate this rule were found.
/// The simple name of the field can be used here as well.
/// Using the full name for consistency with other maps.
return(MapAssignmentIntoContext(memberFullName, assignedValue));
}
private void PostProcessMappings(StatementCollection getEnumeratorStatements)
{
V_0 = getEnumeratorStatements.GetEnumerator();
try
{
while (V_0.MoveNext())
{
V_1 = V_0.get_Current();
if (V_1.get_CodeNodeType() != 5 || (V_1 as ExpressionStatement).get_Expression().get_CodeNodeType() != 24)
{
continue;
}
V_2 = (V_1 as ExpressionStatement).get_Expression() as BinaryExpression;
if (!V_2.get_IsAssignmentExpression() || V_2.get_Left().get_CodeNodeType() != 30 || V_2.get_Right().get_CodeNodeType() != 30)
{
continue;
}
V_3 = (V_2.get_Left() as FieldReferenceExpression).get_Field().Resolve();
V_4 = (V_2.get_Right() as FieldReferenceExpression).get_Field().Resolve();
if (!this.parameterMappings.TryGetValue(V_4, out V_5))
{
continue;
}
dummyVar0 = this.parameterMappings.Remove(V_4);
this.parameterMappings.set_Item(V_3, V_5);
}
}
finally
{
if (V_0 != null)
{
V_0.Dispose();
}
}
return;
}
private bool Match(StatementCollection statements)
{
this.statements = statements;
yieldDeclaringType = GetGeneratedType();
if (yieldDeclaringType == null)
{
return(false);
}
IEnumerable <Statement> moveNextMethodStatements = GetStatements();
if (moveNextMethodStatements == null || yieldData == null)
{
return(false);
}
if (statements.Count > 2)
{
SetParameterMappings();
StatementCollection getEnumeratorStatements = GetEnumeratorStatements();
if (getEnumeratorStatements != null)
{
PostProcessMappings(getEnumeratorStatements);
}
}
newStatements = new StatementCollection();
foreach (Statement statement in moveNextMethodStatements)
{
newStatements.Add(statement);
}
return(true);
}
public void TestTuples1()
{
Boo.Lang.Ast.Module module = BooTestCaseUtil.ParseTestCase("tuples_1.boo");
StatementCollection sc = module.Globals.Statements;
Assert.AreEqual(4, sc.Count);
BinaryExpression ae = (BinaryExpression)((ExpressionStatement)sc[0]).Expression;
Assert.AreEqual("names", ((ReferenceExpression)ae.Left).Name);
TupleLiteralExpression tle = (TupleLiteralExpression)ae.Right;
Assert.AreEqual(3, tle.Items.Count);
ae = (BinaryExpression)((ExpressionStatement)sc[1]).Expression;
tle = (TupleLiteralExpression)ae.Right;
Assert.AreEqual(3, tle.Items.Count);
ae = (BinaryExpression)((ExpressionStatement)sc[3]).Expression;
tle = (TupleLiteralExpression)ae.Right;
Assert.AreEqual(1, tle.Items.Count);
}
private List <int> GetStatementsToInline(StatementCollection statements)
{
List <int> result = new List <int>();
BlockStatement parent = (BlockStatement)statements[0].Parent;
if (parent == null)
{
throw new NullReferenceException("parent");
}
foreach (KeyValuePair <VariableDefinition, DefineUseCount> pair in patternsContext.VariableToDefineUseCountContext)
{
if (pair.Value.DefineCount != 1 || pair.Value.UseCount != 1)
{
continue;
}
ExpressionStatement defineExpression = patternsContext.VariableToSingleAssignmentMap[pair.Key];
if (defineExpression.Parent != parent)
{
continue;
}
int index = statements.IndexOf(defineExpression);
if (index == -1)
{
throw new IndexOutOfRangeException("index");
}
result.Add(index);
}
result.Sort();
return(result);
}
private bool Match()
{
if (this.originalStatements.Count == 0)
{
return(false);
}
if (!this.methodContext.Method.IsAsync(out this.stateMachineTypeDef))
{
if (!this.methodContext.Method.HasAsyncAttributes() || !IsAsyncFirstAssignmentStatement(this.originalStatements[0], out this.stateMachineTypeDef) ||
!this.methodContext.Method.HasAsyncStateMachineVariable())
{
return(false);
}
}
if (!GetBuilderField())
{
return(false);
}
asyncStatements = GetMoveNextStatements();
if (asyncStatements == null || !TryRemoveOuterTryCatch(asyncStatements))
{
return(false);
}
SetParameterMappings(originalStatements);
matcherState = MatcherState.FindAwaitExpression;
asyncStatements = (StatementCollection)Visit(asyncStatements);
bool result = matcherState == MatcherState.FindAwaitExpression;
return(result);
}
private bool TryGetAssignment(StatementCollection statements, int startIndex, out BinaryExpression binaryExpression)
{
binaryExpression = null;
var statement = statements[startIndex];
if (statement.CodeNodeType != CodeNodeType.ExpressionStatement)
{
return false;
}
Expression firstExpression = (statement as ExpressionStatement).Expression;
if (firstExpression.CodeNodeType != CodeNodeType.BinaryExpression)
{
return false;
}
var result = firstExpression as BinaryExpression;
if (!result.IsAssignmentExpression)
{
return false;
}
if (!(result.Left.CodeNodeType == CodeNodeType.VariableReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.VariableDeclarationExpression ||
result.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.ThisReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.PropertyReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.ArgumentReferenceExpression ||
result.Left.CodeNodeType == CodeNodeType.UnaryExpression && (result.Left as UnaryExpression).Operand.CodeNodeType == CodeNodeType.ArgumentReferenceExpression))
{
return false;
}
binaryExpression = result;
return true;
}
private StatementCollection GetStatementsForInvocation(out int endIndex, out int startIndex, out bool isBaseCtor)
{
startIndex = 0;
V_0 = this.methodBodyBlock.get_Statements();
V_1 = new StatementCollection();
isBaseCtor = false;
V_2 = 0;
while (V_2 < V_0.get_Count())
{
if (!this.IsVariableDeclaration(V_0.get_Item(V_2)) || V_1.get_Count() != 0)
{
V_1.Add(V_0.get_Item(V_2).Clone());
if (this.IsCtorInvocation(V_0.get_Item(V_2), out isBaseCtor))
{
if (!isBaseCtor)
{
break;
}
this.methodContext.set_IsBaseConstructorInvokingConstructor(true);
break;
}
}
else
{
startIndex = startIndex + 1;
}
V_2 = V_2 + 1;
}
endIndex = V_2;
if (V_2 == V_0.get_Count())
{
endIndex = -1;
V_1 = null;
}
return(V_1);
}
private void PostProcessMappings(StatementCollection getEnumeratorStatements)
{
foreach (Statement statement in getEnumeratorStatements)
{
if (statement.CodeNodeType == CodeNodeType.ExpressionStatement &&
(statement as ExpressionStatement).Expression.CodeNodeType == CodeNodeType.BinaryExpression)
{
BinaryExpression binaryExpression = (statement as ExpressionStatement).Expression as BinaryExpression;
if (binaryExpression.IsAssignmentExpression && binaryExpression.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression &&
binaryExpression.Right.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldDefinition leftFieldDef = (binaryExpression.Left as FieldReferenceExpression).Field.Resolve();
FieldDefinition rightFieldDef = (binaryExpression.Right as FieldReferenceExpression).Field.Resolve();
Expression fieldValue;
if (parameterMappings.TryGetValue(rightFieldDef, out fieldValue))
{
parameterMappings.Remove(rightFieldDef);
parameterMappings[leftFieldDef] = fieldValue;
}
}
}
}
}
protected abstract bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount);
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
if (!this.TryGetObjectCreation(statements, startIndex, out V_0, out V_1))
{
return(false);
}
V_2 = new ExpressionCollection();
V_3 = new HashSet <string>();
if (V_0.get_Initializer() != null)
{
if (V_0.get_Initializer().get_InitializerType() != 1)
{
return(false);
}
V_4 = V_0.get_Initializer().get_Expressions().GetEnumerator();
try
{
while (V_4.MoveNext())
{
V_5 = V_4.get_Current();
V_6 = this.GetName((V_5 as BinaryExpression).get_Left());
dummyVar0 = V_3.Add(V_6);
}
}
finally
{
if (V_4 != null)
{
V_4.Dispose();
}
}
}
V_7 = startIndex + 1;
while (V_7 < statements.get_Count() && this.TryGetNextExpression(statements.get_Item(V_7), out V_8))
{
V_9 = V_8 as BinaryExpression;
if (!this.IsObjectPropertyOrFieldAssignment(V_9, V_1))
{
break;
}
V_10 = null;
if (V_9.get_Left().get_CodeNodeType() != 42)
{
if (V_9.get_Left().get_CodeNodeType() == 30)
{
V_13 = (V_9.get_Left() as FieldReferenceExpression).get_Field().Resolve();
if (!this.Visit(V_13.get_Name(), V_3))
{
break;
}
V_10 = new FieldInitializerExpression(V_13, V_13.get_FieldType(), V_9.get_Left().get_UnderlyingSameMethodInstructions());
}
}
else
{
V_12 = (V_9.get_Left() as PropertyReferenceExpression).get_Property();
if (!this.Visit(V_12.get_Name(), V_3))
{
break;
}
V_10 = new PropertyInitializerExpression(V_12, V_12.get_PropertyType(), V_9.get_Left().get_UnderlyingSameMethodInstructions());
}
V_11 = new BinaryExpression(26, V_10, V_9.get_Right().Clone(), this.typeSystem, null, false);
V_2.Add(V_11);
V_7 = V_7 + 1;
}
if (V_2.get_Count() == 0)
{
return(false);
}
if (V_0.get_Initializer() != null)
{
V_4 = V_2.GetEnumerator();
try
{
while (V_4.MoveNext())
{
V_15 = V_4.get_Current();
V_0.get_Initializer().get_Expressions().Add(V_15);
}
}
finally
{
if (V_4 != null)
{
V_4.Dispose();
}
}
}
else
{
V_14 = new InitializerExpression(V_2, 1);
V_14.set_IsMultiLine(true);
V_0.set_Initializer(V_14);
}
result = statements.get_Item(startIndex);
replacedStatementsCount = V_2.get_Count() + 1;
return(true);
}
/// Pattern:
/// field = Expression;
/// where
/// Expression is either array creation expression, literal constant, consturctor call from another class
/// or combination of all of the above.
private bool TryMatchDirectAssignmentInternal(StatementCollection statements)
{
ExpressionStatement theStatement = statements[0] as ExpressionStatement;
if (theStatement == null || !string.IsNullOrEmpty(statements[0].Label))
{
return false;
}
string memberFullName;
Expression assignedValue;
if (!IsFieldAssignment(theStatement, out assignedValue, out memberFullName) &&
!IsAutoPropertyAssignment(theStatement, out assignedValue, out memberFullName))
{
return false;
}
/// A check of wheather the assigned value can be used in field declaration context could be performed.
/// At the moment, no IL samples that violate this rule were found.
/// The simple name of the field can be used here as well.
/// Using the full name for consistency with other maps.
return MapAssignmentIntoContext(memberFullName, assignedValue);
}
public BlockExpression()
{
Body = new StatementCollection();
}
public CodePatternsContext(StatementCollection statements)
{
this();
(new CodePatternsContext.VariableDefineUseCounter(this)).Visit(statements);
return;
}
public ExpressionStatement LastExpressionStatement(Method method)
{
StatementCollection statements = method.Body.Statements;
return((statements.Count != 0) ? (statements[-1] as ExpressionStatement) : null);
}
private void RemoveFirstStatements(StatementCollection statements, int count)
{
for (int i = 0; i + count < statements.Count; i++)
{
statements[i] = statements[i + count];
}
while (count-- > 0)
{
statements.RemoveAt(statements.Count - 1);
}
}
protected bool TryGetArrayCreation(StatementCollection statements, int startIndex, out ArrayCreationExpression creation, out Expression assignee)
{
assignee = null;
creation = null;
BinaryExpression binaryExpression;
if (!TryGetAssignment(statements, startIndex, out binaryExpression))
{
return false;
}
if (binaryExpression.Right.CodeNodeType != CodeNodeType.ArrayCreationExpression)
{
return false;
}
var arrayCreation = binaryExpression.Right as ArrayCreationExpression;
if (!(binaryExpression.Right.HasType && binaryExpression.Right.ExpressionType.IsArray))
{
return false;
}
/// Implemented for 1-dimentional arrays only.
/// This covers most of the cases, and is far easier to implement than support
/// for n-dimentional arrays.
if (arrayCreation.Dimensions.Count != 1)
{
return false;
}
foreach (Expression dimention in arrayCreation.Dimensions)
{
if (dimention.CodeNodeType != CodeNodeType.LiteralExpression)
{
return false;
}
}
creation = binaryExpression.Right as ArrayCreationExpression;
assignee = binaryExpression.Left;
return true;
}
private void RemoveRange(StatementCollection statements, int startIndex, int length)
{
if (length == 0)
{
return;
}
int count = statements.Count;
for (int i = startIndex; i + length < count; i++)
{
statements[i] = statements[i + length];
}
while (length > 0)
{
statements.RemoveAt(--count);
length--;
}
}
private bool HasNoEmptyStatements(StatementCollection statements)
{
foreach (Statement statement in statements)
{
if (!(statement is EmptyStatement))
{
return true;
}
}
return false;
}
private bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result)
{
result = null;
if (startIndex + 1 >= statements.get_Count())
{
return(false);
}
if (statements.get_Item(startIndex).get_CodeNodeType() != 5 || statements.get_Item(startIndex + 1).get_CodeNodeType() != 3)
{
return(false);
}
V_0 = statements.get_Item(startIndex) as ExpressionStatement;
if (V_0.get_Expression().get_CodeNodeType() != 24)
{
return(false);
}
V_1 = V_0.get_Expression() as BinaryExpression;
if (V_1.get_Left().get_CodeNodeType() != 26 || V_1.get_Right().get_CodeNodeType() != 48)
{
return(false);
}
V_2 = V_1.get_Left() as VariableReferenceExpression;
V_3 = V_1.get_Right() as EventReferenceExpression;
V_4 = statements.get_Item(startIndex + 1) as IfStatement;
if (V_4.get_Then() == null || V_4.get_Else() != null || V_4.get_Condition().get_CodeNodeType() != 24)
{
return(false);
}
V_5 = V_4.get_Condition() as BinaryExpression;
if (V_5.get_Left().get_CodeNodeType() != 26 || V_5.get_Right().get_CodeNodeType() != 22 || V_5.get_Operator() != 10)
{
return(false);
}
V_6 = V_5.get_Left() as VariableReferenceExpression;
if ((object)V_2.get_Variable() != (object)V_6.get_Variable())
{
return(false);
}
if ((V_5.get_Right() as LiteralExpression).get_Value() != null)
{
return(false);
}
V_7 = V_4.get_Then().get_Statements();
if (V_7.get_Count() != 1 || V_7.get_Item(0).get_CodeNodeType() != 5)
{
return(false);
}
V_8 = V_7.get_Item(0) as ExpressionStatement;
if (V_8.get_Expression().get_CodeNodeType() != 51)
{
return(false);
}
V_9 = V_8.get_Expression() as DelegateInvokeExpression;
if (V_9.get_Target() == null || V_9.get_Target().get_CodeNodeType() != 26)
{
return(false);
}
V_10 = V_9.get_Target() as VariableReferenceExpression;
if ((object)V_10.get_Variable() != (object)V_2.get_Variable())
{
return(false);
}
V_11 = new List <Instruction>();
V_11.AddRange(V_0.get_UnderlyingSameMethodInstructions());
V_11.AddRange(V_5.get_UnderlyingSameMethodInstructions());
V_11.AddRange(V_9.get_MappedInstructions());
V_11.AddRange(V_10.get_UnderlyingSameMethodInstructions());
result = new ExpressionStatement(new RaiseEventExpression(V_3.get_Event(), V_9.get_InvokeMethodReference(), V_9.get_Arguments(), V_11));
return(true);
}
public For()
{
Next = new StatementCollection();
}
private void RemoveRangeAndInsert(StatementCollection statements, int startIndex, int length, Statement newStatement)
{
statements.set_Item(startIndex, newStatement);
this.RemoveRange(statements, startIndex + 1, length - 1);
return;
}
protected bool TryGetObjectCreation(StatementCollection statements, int startIndex, out ObjectCreationExpression creation, out Expression assignee)
{
assignee = null;
creation = null;
BinaryExpression binaryExpression;
if (!TryGetAssignment(statements, startIndex, out binaryExpression))
{
return false;
}
if (binaryExpression.Right.CodeNodeType != CodeNodeType.ObjectCreationExpression)
{
return false;
}
assignee = binaryExpression.Left;
creation = binaryExpression.Right as ObjectCreationExpression;
return true;
}
// Person person = new Person { Name = "John", Age = 20 };
//
// ==
//
// Person person = new Person();
// person.Name = "John";
// person.Age = 20;
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
ObjectCreationExpression objectCreation;
Expression assignee;
if (!TryGetObjectCreation(statements, startIndex, out objectCreation, out assignee))
{
return false;
}
ExpressionCollection inlinedExpressions = new ExpressionCollection();
HashSet<string> visitedPropertyNames = new HashSet<string>();
if (objectCreation.Initializer != null)
{
if (objectCreation.Initializer.InitializerType != InitializerType.ObjectInitializer)
{
return false;
}
foreach (var item in objectCreation.Initializer.Expressions)
{
string name = GetName((item as BinaryExpression).Left);
visitedPropertyNames.Add(name);
}
}
for (int i = startIndex + 1; i < statements.Count; i++)
{
Expression expression;
if (!TryGetNextExpression(statements[i], out expression))
{
break;
}
BinaryExpression assignment = expression as BinaryExpression;
if (!IsObjectPropertyOrFieldAssignment(assignment, assignee))
{
break;
}
Expression initializer = null;
if (assignment.Left.CodeNodeType == CodeNodeType.PropertyReferenceExpression)
{
PropertyDefinition property = (assignment.Left as PropertyReferenceExpression).Property;
if (!Visit(property.Name, visitedPropertyNames))
{
break;
}
initializer = new PropertyInitializerExpression(property, property.PropertyType,
assignment.Right.UnderlyingSameMethodInstructions);
}
else if (assignment.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldDefinition field = (assignment.Left as FieldReferenceExpression).Field.Resolve();
if (!Visit(field.Name, visitedPropertyNames))
{
break;
}
initializer = new FieldInitializerExpression(field, field.FieldType,
assignment.Right.UnderlyingSameMethodInstructions);
}
var inlinedAssignment = new BinaryExpression(BinaryOperator.Assign,
initializer, assignment.Right.Clone(), this.typeSystem, null);
inlinedExpressions.Add(inlinedAssignment);
}
if (inlinedExpressions.Count == 0)
{
return false;
}
if (objectCreation.Initializer == null)
{
var initializer = new InitializerExpression(inlinedExpressions, InitializerType.ObjectInitializer);
initializer.IsMultiLine = true;
objectCreation.Initializer = initializer;
}
else
{
foreach (var item in inlinedExpressions)
{
objectCreation.Initializer.Expressions.Add(item);
}
}
result = statements[startIndex];
replacedStatementsCount = inlinedExpressions.Count + 1;
return true;
}
/// <summary>
/// Creates a new parse tree for a constructor declaration.
/// </summary>
/// <param name="attributes">The attributes for the parse tree.</param>
/// <param name="modifiers">The modifiers for the parse tree.</param>
/// <param name="keywordLocation">The location of the keyword.</param>
/// <param name="name">The name of the declaration.</param>
/// <param name="parameters">The parameters of the declaration.</param>
/// <param name="statements">The statements in the declaration.</param>
/// <param name="endDeclaration">The end block declaration, if any.</param>
/// <param name="span">The location of the parse tree.</param>
/// <param name="comments">The comments for the parse tree.</param>
public ConstructorDeclaration(AttributeBlockCollection attributes, ModifierCollection modifiers, Location keywordLocation, SimpleName name, ParameterCollection parameters, StatementCollection statements, EndBlockDeclaration endDeclaration, Span span, IList <Comment> comments) : base(TreeType.ConstructorDeclaration, attributes, modifiers, keywordLocation, name, null, parameters, Location.Empty, null, null,
null, null, statements, endDeclaration, span, comments)
{
}
public virtual ICollection <Statement> Visit(StatementCollection node)
{
return(Visit <StatementCollection, Statement>(node));
}
// Person person = new Person { Name = "John", Age = 20 };
//
// ==
//
// Person person = new Person();
// person.Name = "John";
// person.Age = 20;
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
ObjectCreationExpression objectCreation;
Expression assignee;
if (!TryGetObjectCreation(statements, startIndex, out objectCreation, out assignee))
{
return(false);
}
ExpressionCollection inlinedExpressions = new ExpressionCollection();
HashSet <string> visitedPropertyNames = new HashSet <string>();
if (objectCreation.Initializer != null)
{
if (objectCreation.Initializer.InitializerType != InitializerType.ObjectInitializer)
{
return(false);
}
foreach (var item in objectCreation.Initializer.Expressions)
{
string name = GetName((item as BinaryExpression).Left);
visitedPropertyNames.Add(name);
}
}
for (int i = startIndex + 1; i < statements.Count; i++)
{
Expression expression;
if (!TryGetNextExpression(statements[i], out expression))
{
break;
}
BinaryExpression assignment = expression as BinaryExpression;
if (!IsObjectPropertyOrFieldAssignment(assignment, assignee))
{
break;
}
Expression initializer = null;
if (assignment.Left.CodeNodeType == CodeNodeType.PropertyReferenceExpression)
{
PropertyDefinition property = (assignment.Left as PropertyReferenceExpression).Property;
if (!Visit(property.Name, visitedPropertyNames))
{
break;
}
initializer = new PropertyInitializerExpression(property, property.PropertyType,
assignment.Left.UnderlyingSameMethodInstructions);
}
else if (assignment.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldDefinition field = (assignment.Left as FieldReferenceExpression).Field.Resolve();
if (!Visit(field.Name, visitedPropertyNames))
{
break;
}
initializer = new FieldInitializerExpression(field, field.FieldType,
assignment.Left.UnderlyingSameMethodInstructions);
}
var inlinedAssignment = new BinaryExpression(BinaryOperator.Assign,
initializer, assignment.Right.Clone(), this.typeSystem, null);
inlinedExpressions.Add(inlinedAssignment);
}
if (inlinedExpressions.Count == 0)
{
return(false);
}
if (objectCreation.Initializer == null)
{
var initializer = new InitializerExpression(inlinedExpressions, InitializerType.ObjectInitializer);
initializer.IsMultiLine = true;
objectCreation.Initializer = initializer;
}
else
{
foreach (var item in inlinedExpressions)
{
objectCreation.Initializer.Expressions.Add(item);
}
}
result = statements[startIndex];
replacedStatementsCount = inlinedExpressions.Count + 1;
return(true);
}
public HashSet <VariableDefinition> Find(StatementCollection statements)
{
return(new HashSet <VariableDefinition>());
}
private static UnifiedBlock CreateStatementCollection(StatementCollection statements)
{
return(statements.SelectMany(CreateStatement).ToBlock());
}
/// <summary>
/// Coppies the block that is targeted from the goto if it matches the case
///
/// ... some code
/// goto: label0;
///
/// ...
/// ...
/// label0: statement1
/// *statements*
/// return;
/// ...
/// </summary>
/// <param name="labeledStatement">The targeted statement.</param>
/// <param name="gotoStatement">The goto statement.</param>
/// <returns>Returns True if the targeted block was coppied.</returns>
private bool TryCopyTargetedBlock(Statement labeledStatement, GotoStatement gotoStatement)
{
StatementCollection toCopy = new StatementCollection();
StatementCollection originalStatements = new StatementCollection();
BlockStatement targetParent = labeledStatement.Parent as BlockStatement;
if (targetParent == null)
{
return false;
}
int targetIndex = targetParent.Statements.IndexOf(labeledStatement);
originalStatements.Add(labeledStatement);
Statement labeledClone = labeledStatement.CloneStatementOnly();
labeledClone.Label = string.Empty;
toCopy.Add(labeledClone);
int maxStatementsToCopy = MaximumStatementsToCopy;
if (ContainsLabel(labeledClone))
{
return false;
}
maxStatementsToCopy -= GetStatementsCount(labeledClone);
if (maxStatementsToCopy < 0)
{
return false;
}
if (!IsReturnStatement(labeledClone) && !IsThrowStatement(labeledClone))
{
///Collect all statements, until a return is reached.
int index;
for (index = targetIndex + 1; index < targetParent.Statements.Count; index++)
{
Statement nextStatement = targetParent.Statements[index];
if (ContainsLabel(nextStatement))
{
return false;
}
maxStatementsToCopy -= GetStatementsCount(nextStatement);
if (maxStatementsToCopy < 0)
{
return false;
}
originalStatements.Add(nextStatement);
Statement clone = nextStatement.CloneStatementOnly();
toCopy.Add(clone);
if (IsReturnStatement(nextStatement) || IsThrowStatement(nextStatement))
{
break;
}
}
if (index == targetParent.Statements.Count)
{
///all the statements were traversed and no 'return' statement was found
return false;
}
}
///Move the coppied statements on the place of the goto statement.
MoveStatements(gotoStatement, toCopy);
///Clean up the label from the targeted statement if possible, and remove the targeted statement if it cannot be reached anymore
if (!Targeted(labeledStatement.Label))
{
UpdateUntargetedStatement(labeledStatement, originalStatements);
}
return true;
}
/// <summary>
/// Constructs a new parse tree for a property accessor.
/// </summary>
/// <param name="attributes">The attributes for the parse tree.</param>
/// <param name="raiseEventLocation">The location of the 'RaiseEvent'.</param>
/// <param name="parameters">The parameters of the declaration.</param>
/// <param name="statements">The statements in the declaration.</param>
/// <param name="endStatement">The end block declaration, if any.</param>
/// <param name="span">The location of the parse tree.</param>
/// <param name="comments">The comments for the parse tree.</param>
public RaiseEventAccessorDeclaration(AttributeBlockCollection attributes, Location raiseEventLocation, ParameterCollection parameters, StatementCollection statements, EndBlockDeclaration endStatement, Span span, IList <Comment> comments) : base(TreeType.RaiseEventAccessorDeclaration, attributes, null, span, comments)
{
SetParent(parameters);
SetParent(statements);
SetParent(endStatement);
_Parameters = parameters;
_RaiseEventLocation = raiseEventLocation;
_Statements = statements;
_EndStatement = endStatement;
}
public Switch()
{
Default = new StatementCollection();
}
public void ShouldSetCollection(IEnumerable <IStatement> statements)
{
var sut = new StatementCollection(statements);
sut.Statements.Should().NotBeNullOrEmpty().And.HaveCount(statements.Count());
}
public ConstructorDeclaration()
{
Arguments = new CodeObjectCollection <MethodArgumentDeclaration>(this);
Statements = new StatementCollection(this);
}
protected abstract bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount);
private void RemoveStatement(StatementCollection collection, Statement statement)
{
collection.Remove(statement);
}
public List<FoldMarker> GenerateFoldMarkers(IDocument document, string fileName, object parseInformation)
{
List<FoldMarker> list = new List<FoldMarker>();
try
{
StatementCollection coll = new StatementCollection((parseInformation as Interpreter).StatementsTree, false);
foreach (Statement st in coll)
if (st is FunctionDefinitionStatement)
{
LineSegment startLine = document.GetLineSegment(st.LineNumber);
LineSegment endLine = document.GetLineSegment(st.LastLineNumber - 1);
while (endLine.Words.Count == 0)
endLine = document.GetLineSegment(endLine.LineNumber - 1);
if (startLine.LineNumber + 3 < endLine.LineNumber)
list.Add(new FoldMarker(document, startLine.LineNumber, startLine.Length - 1, endLine.LineNumber, endLine.Length));
}
}
catch { }
return list;
}
//Removes statements from index to index + length - 1
//Inserts newStatement at index
private void RemoveRangeAndInsert(StatementCollection statements, int startIndex, int length, Statement newStatement)
{
statements[startIndex] = newStatement;
RemoveRange(statements, startIndex + 1, length - 1);
}
public static IEnumerable <T> WithExpressionStatementOfType <T>(this StatementCollection source) where T : Expression
{
var found = source.OfType <ExpressionStatement>().Where(stmt => stmt.Expression.GetType() == typeof(T));
return(found.Select(stmt => (T)stmt.Expression));
}
/// <summary>
/// Constructs a new parse tree for a property accessor.
/// </summary>
/// <param name="attributes">The attributes for the parse tree.</param>
/// <param name="modifiers">The modifiers for the parse tree.</param>
/// <param name="setLocation">The location of the 'Set'.</param>
/// <param name="parameters">The parameters of the declaration.</param>
/// <param name="statements">The statements in the declaration.</param>
/// <param name="endDeclaration">The end block declaration, if any.</param>
/// <param name="span">The location of the parse tree.</param>
/// <param name="comments">The comments for the parse tree.</param>
public SetAccessorDeclaration(AttributeBlockCollection attributes, ModifierCollection modifiers, Location setLocation, ParameterCollection parameters, StatementCollection statements, EndBlockDeclaration endDeclaration, Span span, IList <Comment> comments) : base(TreeType.SetAccessorDeclaration, attributes, modifiers, span, comments)
{
SetParent(parameters);
SetParent(statements);
SetParent(endDeclaration);
_Parameters = parameters;
_SetLocation = setLocation;
_Statements = statements;
_EndDeclaration = endDeclaration;
}
//a0 = a1 = a2 = ... = aN;
//
//==
//
//x = aN;
//aN-1 = x;
//...
//a1 = x;
//a0 = x;
//
//x - phi variable
//a(0 - N-1) - phi variables or parameters
//aN - expression
//result -> x = a0 = a1 = a2 = ... = aN
//it will be used for inlining in a method invocation
private bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount, out VariableDefinition xVariableDef)
{
result = null;
replacedStatementsCount = 0;
xVariableDef = null;
if (statements.Count < 1 || statements[startIndex].CodeNodeType != CodeNodeType.ExpressionStatement)
{
return(false);
}
VariableReference xVariableReference;
Expression theAssignedExpression;
BinaryExpression valueToXAssignExpression = (statements[startIndex] as ExpressionStatement).Expression as BinaryExpression;
if (!IsAssignToVariableExpression(valueToXAssignExpression, out xVariableReference) ||
!this.methodContext.StackData.VariableToDefineUseInfo.ContainsKey(xVariableReference.Resolve()))
{
return(false);
}
theAssignedExpression = valueToXAssignExpression.Right;
int currentIndex = startIndex + 1;
for (; currentIndex < statements.Count; currentIndex++)
{
Statement currentStatement = statements[currentIndex];
if (currentStatement.CodeNodeType != CodeNodeType.ExpressionStatement || !string.IsNullOrEmpty(currentStatement.Label))
{
break;
}
BinaryExpression xToVarAssignExpression = (currentStatement as ExpressionStatement).Expression as BinaryExpression;
if (xToVarAssignExpression == null || !xToVarAssignExpression.IsAssignmentExpression ||
xToVarAssignExpression.Right.CodeNodeType != CodeNodeType.VariableReferenceExpression ||
(xToVarAssignExpression.Right as VariableReferenceExpression).Variable != xVariableReference)
{
break;
}
if (xToVarAssignExpression.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
return(false);
}
if (xToVarAssignExpression.Left.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
VariableDefinition assignedVariable = (xToVarAssignExpression.Left as VariableReferenceExpression).Variable.Resolve();
if (assignedVariable == xVariableReference)
{
return(false);
}
variablesToRemove.Add(assignedVariable);
}
theAssignedExpression = new BinaryExpression(BinaryOperator.Assign, xToVarAssignExpression.Left, theAssignedExpression, typeSystem, null);
}
replacedStatementsCount = currentIndex - startIndex;
if (replacedStatementsCount == 1)
{
return(false);
}
BinaryExpression inlinedAssign = new BinaryExpression(BinaryOperator.Assign,
new VariableReferenceExpression(xVariableReference, null), theAssignedExpression, typeSystem, null);
result = new ExpressionStatement(inlinedAssign)
{
Parent = statements[startIndex].Parent
};
xVariableDef = xVariableReference.Resolve();
return(true);
}
public ClassDefinition GetContextFieldDeclaration()
{
Field field;
Field field2;
ParameterDeclaration declaration;
MemberReferenceExpression expression;
ReferenceExpression expression2;
BinaryExpression expression3;
ReferenceExpression expression4;
ReferenceExpression expression5;
MemberReferenceExpression expression6;
BinaryExpression expression7;
Block block;
Constructor constructor;
ClassDefinition definition;
Type type = this._evaluationContext.GetType();
Type type2 = this._evaluationContext.ScriptContainer.GetType();
ClassDefinition definition1 = definition = new ClassDefinition(LexicalInfo.Empty);
string text1 = definition.Name = "_";
TypeMember[] items = new TypeMember[3];
Field field1 = field = new Field(LexicalInfo.Empty);
int num1 = (int)(field.Modifiers = TypeMemberModifiers.Static | TypeMemberModifiers.Public);
string text2 = field.Name = "ScriptContainer";
TypeReference reference1 = field.Type = TypeReference.Lift(type2);
int num2 = (int)(field.IsVolatile = false);
items[0] = field;
Field field3 = field2 = new Field(LexicalInfo.Empty);
string text3 = field2.Name = "EvaluationContext";
TypeReference reference4 = field2.Type = TypeReference.Lift(type);
int num3 = (int)(field2.IsVolatile = false);
items[1] = field2;
Constructor constructor1 = constructor = new Constructor(LexicalInfo.Empty);
string text4 = constructor.Name = "constructor";
ParameterDeclaration[] parameters = new ParameterDeclaration[1];
ParameterDeclaration declaration1 = declaration = new ParameterDeclaration(LexicalInfo.Empty);
string text5 = declaration.Name = "context";
TypeReference reference5 = declaration.Type = TypeReference.Lift(type);
parameters[0] = declaration;
ParameterDeclarationCollection collection1 = constructor.Parameters = ParameterDeclarationCollection.FromArray(false, parameters);
Block block1 = block = new Block(LexicalInfo.Empty);
Statement[] statementArray1 = new Statement[2];
BinaryExpression expression1 = expression3 = new BinaryExpression(LexicalInfo.Empty);
int num4 = (int)(expression3.Operator = BinaryOperatorType.Assign);
MemberReferenceExpression expression14 = expression = new MemberReferenceExpression(LexicalInfo.Empty);
string text6 = expression.Name = "EvaluationContext";
SelfLiteralExpression expression15 = expression.Target = new SelfLiteralExpression(LexicalInfo.Empty);
MemberReferenceExpression expression16 = expression3.Left = expression;
ReferenceExpression expression17 = expression2 = new ReferenceExpression(LexicalInfo.Empty);
string text7 = expression2.Name = "context";
ReferenceExpression expression18 = expression3.Right = expression2;
statementArray1[0] = Statement.Lift(expression3);
BinaryExpression expression19 = expression7 = new BinaryExpression(LexicalInfo.Empty);
int num5 = (int)(expression7.Operator = BinaryOperatorType.Assign);
ReferenceExpression expression20 = expression4 = new ReferenceExpression(LexicalInfo.Empty);
string text8 = expression4.Name = "ScriptContainer";
ReferenceExpression expression21 = expression7.Left = expression4;
MemberReferenceExpression expression22 = expression6 = new MemberReferenceExpression(LexicalInfo.Empty);
string text9 = expression6.Name = "ScriptContainer";
ReferenceExpression expression23 = expression5 = new ReferenceExpression(LexicalInfo.Empty);
string text10 = expression5.Name = "context";
ReferenceExpression expression24 = expression6.Target = expression5;
MemberReferenceExpression expression25 = expression7.Right = expression6;
statementArray1[1] = Statement.Lift(expression7);
StatementCollection collection2 = block.Statements = StatementCollection.FromArray(statementArray1);
Block block3 = constructor.Body = block;
items[2] = constructor;
TypeMemberCollection collection3 = definition.Members = TypeMemberCollection.FromArray(items);
return(definition);
}
public bool TryMatch(StatementCollection statements,out int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 1;
for (startIndex = 0; startIndex < statements.Count; startIndex++)
{
if (statements[startIndex].CodeNodeType != CodeNodeType.IfStatement)
{
continue;
}
if (TryMatchInternal(statements[startIndex] as IfStatement, out result))
{
return true;
}
}
return false;
}
