public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
Guard.AgainstNullArgument("methodDeclaration", methodDeclaration);
IEnumerable<ParameterDeclaration> parameters = methodDeclaration
.GetChildrenByRole(Roles.Parameter)
.Select(x => (ParameterDeclaration)x.Clone());
var isVoid = false;
var isAsync = methodDeclaration.Modifiers.HasFlag(Modifiers.Async);
AstType returnType = methodDeclaration.GetChildByRole(Roles.Type).Clone();
var type = returnType as PrimitiveType;
if (type != null)
{
isVoid = string.Compare(
type.Keyword, "void", StringComparison.OrdinalIgnoreCase) == 0;
}
var methodType = new SimpleType(Identifier.Create(isVoid ? "Action" : "Func"));
IEnumerable<AstType> types = parameters.Select(
x => x.GetChildByRole(Roles.Type).Clone());
methodType
.TypeArguments
.AddRange(types);
if (!isVoid)
{
methodType.TypeArguments.Add(returnType);
}
var methodName = GetIdentifierName(methodDeclaration);
var methodBody = methodDeclaration
.GetChildrenByRole(Roles.Body)
.FirstOrDefault();
if (methodBody == null)
{
throw new NullReferenceException(string.Format("Method '{0}' has no method body", methodName));
}
methodBody = (BlockStatement)methodBody.Clone();
var prototype = new VariableDeclarationStatement { Type = methodType };
prototype.Variables.Add(new VariableInitializer(methodName));
var anonymousMethod = new AnonymousMethodExpression(methodBody, parameters) { IsAsync = isAsync };
var expression = new ExpressionStatement
{
Expression = new AssignmentExpression(
new IdentifierExpression(methodName),
anonymousMethod)
};
_methods.Add(new MethodVisitorResult
{
MethodDefinition = methodDeclaration,
MethodPrototype = prototype,
MethodExpression = expression
});
}
public override Statement VisitAssignmentStatement(AssignmentStatement assignment)
{
MemberBinding binding = assignment.Target as MemberBinding;
if (binding != null)
{
Expression target = VisitExpression(binding.TargetObject);
Field boundMember = (Field) binding.BoundMember;
Expression source = VisitExpression(assignment.Source);
if (!boundMember.IsStatic && !boundMember.DeclaringType.IsValueType && boundMember.DeclaringType.Contract != null && boundMember.DeclaringType.Contract.FramePropertyGetter != null && boundMember != boundMember.DeclaringType.Contract.FrameField)
{
Local targetLocal = new Local(boundMember.DeclaringType);
Statement evaluateTarget = new AssignmentStatement(targetLocal, target, assignment.SourceContext);
Local sourceLocal = new Local(boundMember.Type);
Statement evaluateSource = new AssignmentStatement(sourceLocal, source, assignment.SourceContext);
Expression guard = new MethodCall(new MemberBinding(targetLocal, boundMember.DeclaringType.Contract.FramePropertyGetter), null, NodeType.Call, SystemTypes.Guard);
Statement check = new ExpressionStatement(new MethodCall(new MemberBinding(guard, SystemTypes.Guard.GetMethod(Identifier.For("CheckIsWriting"))), null, NodeType.Call, SystemTypes.Void));
Statement stfld = new AssignmentStatement(new MemberBinding(targetLocal, boundMember), sourceLocal, assignment.SourceContext);
return new Block(new StatementList(new Statement[] {evaluateTarget, evaluateSource, check, stfld}));
}
else
{
binding.TargetObject = target;
assignment.Source = source;
return assignment;
}
}
else
{
return base.VisitAssignmentStatement(assignment);
}
}
public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode<PropertyDeclaration>();
if (property == null || !property.NameToken.Contains(context.Location))
yield break;
var field = RemoveBackingStoreAction.GetBackingField(context);
if (field == null)
yield break;
var resolvedType = ReflectionHelper.ParseReflectionName ("System.EventHandler").Resolve (context.Compilation);
if (resolvedType == null)
yield break;
var type = (TypeDeclaration)property.Parent;
yield return new CodeAction(context.TranslateString("Create changed event"), script => {
var eventDeclaration = CreateChangedEventDeclaration (context, property);
var methodDeclaration = CreateEventInvocatorAction.CreateEventInvocator (context, type, eventDeclaration, eventDeclaration.Variables.First (), resolvedType.GetDelegateInvokeMethod (), false);
var stmt = new ExpressionStatement (new InvocationExpression (
new IdentifierExpression (methodDeclaration.Name),
new MemberReferenceExpression (context.CreateShortType("System", "EventArgs"), "Empty")
));
script.InsertWithCursor(
context.TranslateString("Create event invocator"),
Script.InsertPosition.After,
new AstNode[] { eventDeclaration, methodDeclaration }
).ContinueScript(delegate {
script.InsertBefore (property.Setter.Body.RBraceToken, stmt);
script.FormatText (stmt);
});
}, property.NameToken);
}
public void FalseLt()
{
var firstop = new IntegerLiteral("2", 0);
var secondop = new IntegerLiteral("1", 0);
var lt = new LogicalOp("<", firstop, secondop, 0);
var assert = new ExpressionStatement("assert", lt, 0);
program.Add(assert);
Assert.Throws<MiniPLAssertionFailed>(() => interpreter.Run(new Program(program)));
}
public override void VisitExpressionStatement(ExpressionStatement expressionStatement)
{
base.VisitExpressionStatement(expressionStatement);
var invocation = expressionStatement.Expression as InvocationExpression;
if (invocation == null)
return;
var rr = ctx.Resolve(invocation) as InvocationResolveResult;
if (rr != null && (rr.Type.IsKnownType(KnownTypeCode.Task) || rr.Type.IsKnownType(KnownTypeCode.TaskOfT))) {
AddIssue(invocation, ctx.TranslateString("Exceptions in async call will be silently ignored because the returned task is unused"));
}
}
public override void VisitExpressionStatement(ExpressionStatement expressionStatement)
{
StartNode(expressionStatement);
expressionStatement.Expression.AcceptVisitor(this);
WriteToken(Roles.Semicolon);
if (_currentStatementIsNotValidCSharp) {
Space();
VisitComment(new Comment(" This is not valid C#, but it represents the IL correctly."));
_currentStatementIsNotValidCSharp = false;
}
NewLine();
EndNode(expressionStatement);
}
public override void Dispatch(ICodeVisitor visitor) {
CompileTimeConstant labelIndex = new CompileTimeConstant(this.rootClass.GetLabelIndex(this.TargetLabel.Name), this.TargetLabel.SourceLocation);
labelIndex.SetContainingExpression(this.TargetLabel);
List<Expression> arguments = new List<Expression>(1);
arguments.Add(labelIndex);
IMethodDefinition constructor = Dummy.Method;
foreach (IMethodDefinition cons in this.rootClass.TypeDefinition.GetMembersNamed(this.Compilation.NameTable.Ctor, false)) {
constructor = cons; break;
}
Expression thisArgument = new CreateObjectInstanceForResolvedConstructor(constructor, arguments, this.SourceLocation);
//^ assume this.ContainingBlock.ContainingMethodDeclaration != null;
MethodCall mcall = new ResolvedMethodCall(this.rootClass.MainMethod.MethodDefinition, thisArgument, new List<Expression>(0), this.SourceLocation);
ExpressionStatement gosub = new ExpressionStatement(mcall);
gosub.Dispatch(visitor);
}
public override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
{
UnaryOperatorExpression uoe = expressionStatement.Expression as UnaryOperatorExpression;
if (uoe != null) {
switch (uoe.Op) {
case UnaryOperatorType.Increment:
case UnaryOperatorType.PostIncrement:
expressionStatement.Expression = new AssignmentExpression(uoe.Expression, AssignmentOperatorType.Add, new PrimitiveExpression(1, "1"));
break;
case UnaryOperatorType.Decrement:
case UnaryOperatorType.PostDecrement:
expressionStatement.Expression = new AssignmentExpression(uoe.Expression, AssignmentOperatorType.Subtract, new PrimitiveExpression(1, "1"));
break;
}
}
return base.VisitExpressionStatement(expressionStatement, data);
}
CodeAction HandleExpressionStatement(RefactoringContext context, ExpressionStatement expressionStatement)
{
var expression = expressionStatement.Expression as AssignmentExpression;
if (expression == null)
return null;
if (!(expression.Right is ObjectCreateExpression))
return null;
var expressionResolveResult = context.Resolve(expression.Left);
if (!(expressionResolveResult is LocalResolveResult) && !(expressionResolveResult is MemberResolveResult))
return null;
IList<AstNode> statements = GetNodes(context.GetNode<Statement>());
var converter = new StatementsToInitializerConverter(context);
var newExpression = converter.ConvertToInitializer(expression, ref statements);
if (statements.Count == 0)
return null;
return MakeAction(context, expression, newExpression, statements);
}
public override Expression VisitMemberBinding(MemberBinding binding)
{
Member boundMember = binding.BoundMember;
if (boundMember is Field && !boundMember.IsStatic && boundMember.DeclaringType != null && boundMember.DeclaringType.Contract != null && boundMember.DeclaringType.Contract.FramePropertyGetter != null && boundMember != boundMember.DeclaringType.Contract.FrameField)
{
Expression target = VisitExpression(binding.TargetObject);
// Since we do not visit member bindings of assignment statements, we know/guess that this is a ldfld.
Local targetLocal = new Local(boundMember.DeclaringType);
Statement evaluateTarget = new AssignmentStatement(targetLocal, target, binding.SourceContext);
Expression guard = new MethodCall(new MemberBinding(targetLocal, boundMember.DeclaringType.Contract.FramePropertyGetter), null, NodeType.Call, SystemTypes.Guard);
Statement check = new ExpressionStatement(new MethodCall(new MemberBinding(guard, SystemTypes.Guard.GetMethod(Identifier.For("CheckIsReading"))), null, NodeType.Call, SystemTypes.Void));
Statement ldfld = new ExpressionStatement(new MemberBinding(targetLocal, boundMember, binding.SourceContext));
return new BlockExpression(new Block(new StatementList(new Statement[] {evaluateTarget, check, ldfld})), binding.Type);
}
else
{
return base.VisitMemberBinding(binding);
}
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
//TODO: implement variable assignment & ctor param
var varInit = context.GetNode<VariableInitializer>();
if (varInit != null) {
AstType type = varInit.GetPrevNode() as AstType;
if (type == null) yield break;
if (varInit.Parent is FieldDeclaration) yield break;
if (CannotExtractField(varInit)) yield break;
yield return new CodeAction(context.TranslateString("Assign to new field"), s=>{
var name = varInit.Name;
FieldDeclaration field = new FieldDeclaration(){
ReturnType = type.Clone(),
Variables = { new VariableInitializer(name) }
};
AstNode nodeToRemove = RemoveDeclaration(varInit) ? varInit.Parent : type;
s.Remove(nodeToRemove, true);
s.InsertWithCursor(context.TranslateString("Insert new field"),Script.InsertPosition.Before,field);
s.FormatText(varInit.Parent);
});
}
var idntf = context.GetNode<Identifier>();
if (idntf == null) yield break;
var paramDec = idntf.Parent as ParameterDeclaration;
if (paramDec != null) {
var ctor = paramDec.Parent as ConstructorDeclaration;
if (ctor == null) yield break;
MemberReferenceExpression thisField = new MemberReferenceExpression(new ThisReferenceExpression(), idntf.Name, new AstType[]{});
var assign = new AssignmentExpression(thisField, AssignmentOperatorType.Assign, new IdentifierExpression(idntf.Name));
var statement = new ExpressionStatement(assign);
var type = (idntf.GetPrevNode() as AstType).Clone();
FieldDeclaration field = new FieldDeclaration(){
ReturnType = type.Clone(),
Variables = { new VariableInitializer(idntf.Name) }
};
yield return new CodeAction(context.TranslateString("Assign to new field"), s=>{
s.InsertWithCursor(context.TranslateString("Insert new field"),Script.InsertPosition.Before,field);
s.AddTo(ctor.Body, statement);
});
}
}
public override T VisitExpressionStatement(ExpressionStatement node)
{
throw new NotImplementedException();
}
public void VisitExpressionStatement(ExpressionStatement expressionStatement)
{
StartNode(expressionStatement);
expressionStatement.Expression.AcceptVisitor(this);
Semicolon();
EndNode(expressionStatement);
}
// ExpressionStatement
public override bool Walk(ExpressionStatement node) { return false; }
protected override string GenerateCode(ITypeDefinition currentClass)
{
bool implementInterface = this.implementInterface.IsChecked == true;
bool hasOnPropertyChanged = HasOnPropertyChanged(currentClass);
bool useEventArgs = false;
AstNode insertionAnchorElement = refactoringContext.GetNode();
if ((insertionAnchorElement == null) || !(insertionAnchorElement.Parent is TypeDeclaration)) {
return null;
}
NewLineNode newLineNode = insertionAnchorElement as NewLineNode;
while (insertionAnchorElement.PrevSibling is NewLineNode)
insertionAnchorElement = insertionAnchorElement.PrevSibling ?? insertionAnchorElement;
using (Script script = refactoringContext.StartScript()) {
TypeDeclaration currentClassDeclaration = insertionAnchorElement.Parent as TypeDeclaration;
if (implementInterface && !currentClass.IsStatic) {
if (!hasOnPropertyChanged) {
var nodes = new List<AstNode>();
if (!currentClass.GetAllBaseTypeDefinitions().Any(bt => bt.FullName == "System.ComponentModel.INotifyPropertyChanged")) {
AstNode nodeBeforeClassBlock = currentClassDeclaration.LBraceToken;
if (nodeBeforeClassBlock.PrevSibling is NewLineNode) {
// There's a new line before the brace, insert before it!
nodeBeforeClassBlock = nodeBeforeClassBlock.PrevSibling;
}
int insertion = editor.Document.GetOffset(nodeBeforeClassBlock.StartLocation);
AstType interfaceTypeNode = refactoringContext.CreateShortType("System.ComponentModel", "INotifyPropertyChanged", 0);
var directBaseTypes = currentClass.DirectBaseTypes.Where(t => t.FullName != "System.Object");
if (currentClassDeclaration.BaseTypes.Count > 0) {
script.InsertText(insertion, ", " + interfaceTypeNode + " ");
} else {
script.InsertText(insertion, " : " + interfaceTypeNode + " ");
}
}
var rt = new GetClassTypeReference("System.ComponentModel", "INotifyPropertyChanged", 0);
var rtResolved = rt.Resolve(refactoringContext.Compilation);
var ev = rtResolved.GetEvents().First(e => e.Name == "PropertyChanged");
EventDeclaration propertyChangedEvent = new EventDeclaration();
propertyChangedEvent.Variables.Add(new VariableInitializer(ev.Name));
propertyChangedEvent.Modifiers = Modifiers.Public;
propertyChangedEvent.ReturnType = refactoringContext.CreateShortType(ev.ReturnType);
nodes.Add(propertyChangedEvent);
MethodDeclaration onEvent = CreateOnEventMethod(ev, currentClass);
nodes.Add(onEvent);
foreach (var node in nodes) {
script.InsertAfter(insertionAnchorElement, node);
AppendNewLine(script, insertionAnchorElement, newLineNode);
}
useEventArgs = false;
} else {
useEventArgs = currentClass.GetMethods().First(m => m.Name == "OnPropertyChanged").Parameters[0].Type.FullName != "System.String";
}
}
foreach (FieldWrapper field in fields.Where(f => f.IsIncluded)) {
var prop = CreateProperty(field.Field, true, field.AddSetter);
if (!field.Field.IsStatic && !currentClass.IsStatic && field.AddSetter && implementInterface) {
var invocation = new ExpressionStatement(CreateInvocation(field.PropertyName, useEventArgs));
var assignment = prop.Setter.Body.Children.ElementAt(0) as Statement;
prop.Setter.Body = new BlockStatement();
BlockStatement elseBlock = new BlockStatement();
elseBlock.Add(assignment.Clone());
elseBlock.Add(invocation);
prop.Setter.Body.Add(
new IfElseStatement(
new BinaryOperatorExpression(new IdentifierExpression(field.MemberName), BinaryOperatorType.InEquality, new IdentifierExpression("value")),
elseBlock
)
);
}
script.InsertAfter(insertionAnchorElement, prop);
AppendNewLine(script, insertionAnchorElement, newLineNode);
}
}
return null;
}
// ExpressionStatement
protected internal virtual bool Walk(ExpressionStatement node) { return true; }
internal static PythonNode Create(NodeInfo info, List <PythonNode> Children)
{
if (Children == null)
{
Children = new List <PythonNode>();
}
var rewriter = new Rewriter(new List <Edit>());
switch (info.NodeType)
{
case "CallExpressionNode":
var target = (Expression)Children[0].InnerNode;
var args = new List <Arg>();
if (Children.Count > 1)
{
for (var i = 1; i < Children.Count; i++)
{
args.Add(rewriter.VisitArg((Arg)Children[i].InnerNode));
}
}
var inner = new CallExpression(rewriter.VisitExpression(target), args.ToArray());
return(new CallExpressionNode(inner)
{
Children = Children
});
case "ArgNode":
var expression = (Expression)Children[0].InnerNode;
var innerArg = (info.NodeValue == null) ? new Arg(rewriter.VisitExpression(expression)) :
new Arg(info.NodeType, expression);
return(new ArgNode(innerArg)
{
Children = Children, Value = innerArg.Name
});
case "BinaryExpressionNode":
var left = (Expression)Children[0].InnerNode;
var right = (Expression)Children[1].InnerNode;
PythonOperator op = info.NodeValue;
var binaryExpression = new BinaryExpression(op, rewriter.VisitExpression(left), rewriter.VisitExpression(right));
return(new BinaryExpressionNode(binaryExpression)
{
Children = Children, Value = binaryExpression.Operator
});
case "AugmentedAssignStatementNode":
var left1 = (Expression)Children[0].InnerNode;
var right1 = (Expression)Children[1].InnerNode;
PythonOperator op1 = info.NodeValue;
var augmentedAssignStatement = new AugmentedAssignStatement(op1, rewriter.VisitExpression(left1), rewriter.VisitExpression(right1));
return(new AugmentedAssignStatementNode(augmentedAssignStatement)
{
Children = Children, Value = augmentedAssignStatement.Operator
});
case "SuiteStatementNode":
var statements = Children.Select(e => rewriter.VisitStatement((Statement)e.InnerNode));
var suiteStatement = new SuiteStatement(statements.ToArray());
return(new SuiteStatementNode(suiteStatement)
{
Children = Children
});
case "WhileStatementNode":
var test = (Expression)Children[0].InnerNode;
var body = (Statement)Children[1].InnerNode;
Statement else_ = (Children.Count == 3) ? rewriter.VisitStatement((Statement)Children[2].InnerNode) : null;
var whileStatement = new WhileStatement(rewriter.VisitExpression(test), rewriter.VisitStatement(body), else_);
return(new WhileStatementNode(whileStatement)
{
Children = Children
});
case "ReturnStatementNode":
var returnStatement = new ReturnStatement(rewriter.VisitExpression((Expression)Children[0].InnerNode));
return(new ReturnStatementNode(returnStatement)
{
Children = Children
});
case "ParameterNode":
var parameter = new Parameter(info.NodeValue);
if (Children.Any())
{
parameter.DefaultValue = rewriter.VisitExpression((Expression)Children[0].InnerNode);
}
return(new ParameterNode(parameter)
{
Children = Children, Value = parameter.Name
});
case "ExpressionStatementNode":
var expressionStatement = new ExpressionStatement(rewriter.VisitExpression((Expression)Children[0].InnerNode));
return(new ExpressionStatementNode(expressionStatement)
{
Children = Children
});
case "ParenthesisExpressionNode":
var parenthesisExpression = new ParenthesisExpression(rewriter.VisitExpression((Expression)Children[0].InnerNode));
return(new ParenthesisExpressionNode(parenthesisExpression)
{
Children = Children
});
case "IfStatementNode":
if (Children.Last().InnerNode is IfStatementTest)
{
var ifStatement = new IfStatement(Children.Select(e => (IfStatementTest)e.InnerNode).ToArray(), null);
return(new IfStatementNode(ifStatement)
{
Children = Children
});
}
var tests = Children.GetRange(0, Children.Count - 1).Select(e => (IfStatementTest)e.InnerNode);
var elseStmt = Children.Last().InnerNode;
var statement = new IfStatement(tests.ToArray(), rewriter.VisitStatement((Statement)elseStmt));
return(new IfStatementNode(statement)
{
Children = Children
});
case "IfStatementTestNode":
var ifStatementTest = new IfStatementTest(rewriter.VisitExpression((Expression)Children[0].InnerNode), rewriter.VisitStatement((Statement)Children[1].InnerNode));
return(new IfStatementTestNode(ifStatementTest)
{
Children = Children
});
case "AssignmentStatementNode":
IEnumerable <Expression> leftAssign = Children.GetRange(0, Children.Count - 1).Select(e => rewriter.VisitExpression((Expression)e.InnerNode));
var assignmentStatement = new AssignmentStatement(leftAssign.ToArray(), rewriter.VisitExpression((Expression)Children.Last().InnerNode));
return(new AssignmentStatementNode(assignmentStatement)
{
Children = Children
});
case "TupleExpressionNode":
IEnumerable <Expression> expressions = Children.Select(e => rewriter.VisitExpression((Expression)e.InnerNode));
var tupleExpression = new TupleExpression(info.NodeValue, expressions.ToArray());
return(new TupleExpressionNode(tupleExpression)
{
Children = Children
});
case "ConditionalExpressionNode":
var condExpression = new ConditionalExpression(rewriter.VisitExpression((Expression)Children[0].InnerNode), rewriter.VisitExpression((Expression)Children[1].InnerNode),
rewriter.VisitExpression((Expression)Children[2].InnerNode));
return(new ConditionalExpressionNode(condExpression)
{
Children = Children
});
//case "FunctionDefinitionNode":
// var funDef = new FunctionDefinition(info.NodeValue, ,rewriter.VisitExpression((Expression)Children[0].InnerNode));
// return new FunctionDefinitionNode(funDef) { Children = Children };
default:
throw new NotImplementedException(info.NodeType);
}
}
public override bool Walk(ExpressionStatement node) => SaveStmt(node, base.Walk(node));
protected override string GenerateCode(LanguageProperties language, IClass currentClass)
{
StringBuilder builder = new StringBuilder();
IDocumentLine line = editor.Document.GetLineForOffset(anchor.Offset);
string indent = DocumentUtilitites.GetWhitespaceAfter(editor.Document, line.Offset);
bool implementInterface = this.implementInterface.IsChecked == true;
bool hasOnPropertyChanged = HasOnPropertyChanged(currentClass);
bool useEventArgs = false;
if (implementInterface && !currentClass.IsStatic)
{
if (!hasOnPropertyChanged)
{
var nodes = new List <AbstractNode>();
var rt = new GetClassReturnType(currentClass.ProjectContent, "System.ComponentModel.INotifyPropertyChanged", 0);
if (!currentClass.ClassInheritanceTree.Any(bt => bt.FullyQualifiedName == "System.ComponentModel.INotifyPropertyChanged"))
{
int insertion = editor.Document.PositionToOffset(currentClass.BodyRegion.BeginLine, currentClass.BodyRegion.BeginColumn);
if (currentClass.BaseTypes.Count > 0)
{
editor.Document.Insert(insertion, ", INotifyPropertyChanged");
}
else
{
editor.Document.Insert(insertion, " : INotifyPropertyChanged");
}
}
language.CodeGenerator.ImplementInterface(nodes, rt, false, currentClass);
var ev = rt.GetEvents().First(e => e.Name == "PropertyChanged");
MethodDeclaration onEvent = language.CodeGenerator.CreateOnEventMethod(new DefaultEvent(ev.Name, ev.ReturnType, ev.Modifiers, ev.Region, ev.BodyRegion, currentClass));
nodes.Add(onEvent);
onEvent.Parameters[0].TypeReference = new TypeReference("string", true);
onEvent.Parameters[0].ParameterName = "propertyName";
((RaiseEventStatement)onEvent.Body.Children[0]).Arguments[1] = new ObjectCreateExpression(new TypeReference("PropertyChangedEventArgs"), new List <Expression> {
new IdentifierExpression("propertyName")
});
foreach (var node in nodes)
{
builder.AppendLine(language.CodeGenerator.GenerateCode(node, indent));
}
useEventArgs = false;
}
else
{
useEventArgs = currentClass.DefaultReturnType.GetMethods().First(m => m.Name == "OnPropertyChanged").Parameters[0].ReturnType.FullyQualifiedName != "System.String";
}
}
foreach (FieldWrapper field in listBox.SelectedItems)
{
var prop = language.CodeGenerator.CreateProperty(field.Field, true, field.AddSetter);
if (!field.Field.IsStatic && !currentClass.IsStatic && field.AddSetter && implementInterface)
{
var invocation = new ExpressionStatement(CreateInvocation(field.PropertyName, useEventArgs));
var assignment = prop.SetRegion.Block.Children[0];
prop.SetRegion.Block.Children.Clear();
prop.SetRegion.Block.AddChild(
new IfElseStatement(
new BinaryOperatorExpression(new IdentifierExpression(field.MemberName), BinaryOperatorType.InEquality, new IdentifierExpression("value")),
new BlockStatement {
Children = { assignment, invocation }
}
)
);
}
builder.AppendLine(language.CodeGenerator.GenerateCode(prop, indent));
}
return(builder.ToString().Trim());
}
public override void VisitExpressionStatement(ExpressionStatement expressionStatement)
{
new ExpressionBlock(this, expressionStatement).Emit();
}
Statement TransformForeachOnMultiDimArray(ExpressionStatement expressionStatement)
{
Match m;
Statement stmt = expressionStatement;
IL.ILVariable collection = null;
IL.ILVariable[] upperBounds = null;
List <Statement> statementsToDelete = new List <Statement>();
int i = 0;
// first we look for all the upper bound initializations
do
{
m = variableAssignUpperBoundPattern.Match(stmt);
if (!m.Success)
{
break;
}
if (upperBounds == null)
{
collection = m.Get <IdentifierExpression>("collection").Single().GetILVariable();
if (!(collection.Type is Decompiler.TypeSystem.ArrayType arrayType))
{
break;
}
upperBounds = new IL.ILVariable[arrayType.Dimensions];
}
else
{
statementsToDelete.Add(stmt);
}
var nextCollection = m.Get <IdentifierExpression>("collection").Single().GetILVariable();
if (nextCollection != collection)
{
break;
}
if (!int.TryParse(m.Get <PrimitiveExpression>("index").Single().Value?.ToString() ?? "", out int index) || index != i)
{
break;
}
upperBounds[i] = m.Get <IdentifierExpression>("variable").Single().GetILVariable();
stmt = stmt.GetNextStatement();
i++;
} while (stmt != null && i < upperBounds.Length);
if (upperBounds?.LastOrDefault() == null || collection == null)
{
return(null);
}
if (!MatchForeachOnMultiDimArray(upperBounds, collection, stmt, out var foreachVariable, out var statements, out var lowerBounds))
{
return(null);
}
statementsToDelete.Add(stmt);
statementsToDelete.Add(stmt.GetNextStatement());
var itemVariable = foreachVariable.GetILVariable();
if (!itemVariable.IsSingleDefinition ||
!upperBounds.All(ub => ub.IsSingleDefinition && ub.LoadCount == 1) ||
!lowerBounds.All(lb => lb.StoreCount == 2 && lb.LoadCount == 3 && lb.AddressCount == 0))
{
return(null);
}
var body = new BlockStatement();
foreach (var statement in statements)
{
body.Statements.Add(statement.Detach());
}
var foreachStmt = new ForeachStatement {
VariableType = context.Settings.AnonymousTypes && itemVariable.Type.ContainsAnonymousType() ? new SimpleType("var") : context.TypeSystemAstBuilder.ConvertType(itemVariable.Type),
VariableName = itemVariable.Name,
InExpression = m.Get <IdentifierExpression>("collection").Single().Detach(),
EmbeddedStatement = body
};
foreach (var statement in statementsToDelete)
{
statement.Detach();
}
//foreachStmt.CopyAnnotationsFrom(forStatement);
itemVariable.Kind = IL.VariableKind.ForeachLocal;
// Add the variable annotation for highlighting (TokenTextWriter expects it directly on the ForeachStatement).
foreachStmt.AddAnnotation(new ILVariableResolveResult(itemVariable, itemVariable.Type));
// TODO : add ForeachAnnotation
expressionStatement.ReplaceWith(foreachStmt);
return(foreachStmt);
}
public Completion ExecuteExpressionStatement(ExpressionStatement expressionStatement)
{
var exprRef = _engine.EvaluateExpression(expressionStatement.Expression);
return(new Completion(Completion.Normal, _engine.GetValue(exprRef), null));
}
public virtual void Visit(ExpressionStatement expression)
{
logVisit(expression);
expression.Expression.Accept(this);
}
public override object Visit (InvalidStatementExpression statementExpression)
{
var result = new ExpressionStatement ();
if (statementExpression.Expression == null)
return result;
var expr = statementExpression.Expression.Accept (this) as Expression;
if (expr != null)
result.AddChild (expr, Roles.Expression);
var location = LocationsBag.GetLocations (statementExpression);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location [0]), Roles.Semicolon), Roles.Semicolon);
return result;
}
public override void Exit(ExpressionStatement node)
{
level--;
}
/// <summary>
/// </summary>
/// <param name="static">
/// </param>
/// <returns>
/// </returns>
public CCodeMethodDeclaration CreateInvokeMethod(bool @static = false)
{
var methodImpl = new MethodImpl
{
Name = this.invoke.Name,
IsVirtual = true,
IsOverride = true,
ReturnType = this.invoke.ReturnType,
ReturnsVoid = this.invoke.ReturnsVoid,
Parameters = this.invoke.Parameters,
ContainingType = this.GetDelegateType(@static),
ReceiverType = this.GetDelegateType(@static)
};
// invoke
var invokeMethod = new CCodeMethodDeclaration(methodImpl);
var operand = @static
? new PointerIndirectionOperator {
Operand = new FieldAccess {
Field = new FieldImpl {
Name = "_memptr"
}
}
}
: (Expression)
new Access
{
ReceiverOpt = new FieldAccess {
Field = new FieldImpl {
Name = "_t", Type = Type
}
},
Expression =
new PointerIndirectionOperator {
Operand = new FieldAccess {
Field = new FieldImpl {
Name = "_memptr"
}
}
}
};
var callExpr = new Call
{
ReceiverOpt = new Parenthesis {
Operand = operand, Type = new TypeImpl {
}
},
Method = new MethodImpl {
Name = string.Empty, Parameters = this.invoke.Parameters
}
};
foreach (var p in this.invoke.Parameters.Select(p => new Parameter {
ParameterSymbol = p
}))
{
callExpr.Arguments.Add(p);
}
// if for multiple delegate
var zero = new Literal {
Value = ConstantValue.Create(0)
};
var invocationCountLocal = new Local {
CustomName = "invocationCount", Type = new TypeImpl {
SpecialType = SpecialType.System_Int32
}
};
var invocationCount = new AssignmentOperator
{
TypeDeclaration = true,
ApplyAutoType = true,
Left = invocationCountLocal,
Right = new Call
{
Method = new MethodImpl {
Name = "ToInt32", Parameters = ImmutableArray <IParameterSymbol> .Empty
},
ReceiverOpt = new FieldAccess
{
ReceiverOpt = new ThisReference()
{
Type = new TypeImpl {
}
},
Field = new FieldImpl {
Name = "_invocationCount", Type = new TypeImpl {
}
},
Type = new TypeImpl {
}
}
}
};
var invocationCountStatement = new ExpressionStatement
{
Expression = invocationCount
};
var iLocal = new Local {
CustomName = "i", Type = new TypeImpl {
SpecialType = SpecialType.System_Int32
}
};
var invokeResult = new Local {
CustomName = "invokeResult", Type = this.invoke.ReturnType
};
// call for 'for'
var callExprInstance = new Call
{
ReceiverOpt = new Cast
{
Type = Type,
CCast = true,
Operand =
new ArrayAccess
{
Expression = new FieldAccess
{
ReceiverOpt = new ThisReference {
Type = new TypeImpl {
}
},
Field = new FieldImpl {
Name = "_invocationList", Type = new TypeImpl {
}
}
},
Indices =
{
iLocal
},
Type = new TypeImpl {
}
}
},
Method = new MethodImpl {
Name = "Invoke", Parameters = this.invoke.Parameters
}
};
foreach (var p in this.invoke.Parameters.Select(p => new Parameter {
ParameterSymbol = p
}))
{
callExprInstance.Arguments.Add(p);
}
var block = new Block
{
Statements =
{
new ForStatement
{
InitializationOpt =
new AssignmentOperator
{
ApplyAutoType = true,
TypeDeclaration = true,
Left = iLocal,
Right = zero
},
ConditionOpt = new BinaryOperator
{
Left = iLocal,
Right = invocationCountLocal,
OperatorKind = BinaryOperatorKind.IntLessThan
},
IncrementingOpt =
new PrefixUnaryExpression {
Value = iLocal, OperatorKind = SyntaxKind.PlusPlusToken
},
Statements = new ExpressionStatement
{
Expression =
this.invoke.ReturnsVoid
? (Expression)callExprInstance
: (Expression) new AssignmentOperator {
Left = invokeResult, Right = callExprInstance
}
}
},
new ReturnStatement {
ExpressionOpt = !this.invoke.ReturnsVoid ? invokeResult : null
}
}
};
if (!this.invoke.ReturnsVoid)
{
block.Statements.Insert(0, new VariableDeclaration {
Local = invokeResult
});
}
var ifInvokeListCountGreaterThen0 = new IfStatement
{
Condition =
new BinaryOperator
{
Left = invocationCountLocal,
Right = zero,
OperatorKind = BinaryOperatorKind.IntGreaterThan
},
IfStatements = block
};
invokeMethod.MethodBodyOpt = new MethodBody(methodImpl)
{
Statements =
{
invocationCountStatement,
ifInvokeListCountGreaterThen0,
this.invoke.ReturnsVoid
? (Statement) new ExpressionStatement {
Expression = callExpr
}
: (Statement) new ReturnStatement {
ExpressionOpt = callExpr
}
}
};
return(invokeMethod);
}
private bool ParseStatement(Block/*!*/ block) {
//parse instructions and put in expression tree until an assignment, void call, branch target, or branch is encountered
StatementList statementList = block.Statements;
Expression expr = null;
Statement statement = null;
bool transferStatement = false;
int startingAddress = 0;
#if !FxCop
SourceContext sourceContext = new SourceContext();
sourceContext.StartPos = this.counter;
#endif
#if !ROTOR
if (this.method.contextForOffset != null){
object sctx = this.method.contextForOffset[this.counter+1];
if (sctx != null) sourceContext = (SourceContext)sctx;
}
#endif
while (true){
bool isStatement = false;
startingAddress = this.counter+1; //Add one so that it is never zero (the latter means no entry to the TrivialHashtable)
#if FxCop || ILOFFSETS
this.ilOffset = this.counter;
this.opCode = this.GetOpCode();
#else
OpCode opCode = this.GetOpCode();
#endif
#if FxCop
if (this.handlerMap.TryGetValue(this.ilOffset, out expr)){
expr.sourceContext = sourceContext;
expr.ILOffset = this.ilOffset;
this.operandStack.Push(expr);
}
#endif
switch (opCode){
case OpCode.Nop: statement = new Statement(NodeType.Nop); goto done;
case OpCode.Break: statement = new Statement(NodeType.DebugBreak); goto done;
case OpCode.Ldarg_0: expr = this.Parameters(0); break;
case OpCode.Ldarg_1: expr = this.Parameters(1); break;
case OpCode.Ldarg_2: expr = this.Parameters(2); break;
case OpCode.Ldarg_3: expr = this.Parameters(3); break;
case OpCode.Ldloc_0: expr = this.locals[0]; break;
case OpCode.Ldloc_1: expr = this.locals[1]; break;
case OpCode.Ldloc_2: expr = this.locals[2]; break;
case OpCode.Ldloc_3: expr = this.locals[3]; break;
case OpCode.Stloc_0: statement = new AssignmentStatement(this.locals[0], PopOperand()); goto done;
case OpCode.Stloc_1: statement = new AssignmentStatement(this.locals[1], PopOperand()); goto done;
case OpCode.Stloc_2: statement = new AssignmentStatement(this.locals[2], PopOperand()); goto done;
case OpCode.Stloc_3: statement = new AssignmentStatement(this.locals[3], PopOperand()); goto done;
case OpCode.Ldarg_S: expr = this.Parameters(this.GetByte()); break;
case OpCode.Ldarga_S: expr = SetType(new UnaryExpression(this.Parameters(this.GetByte()), NodeType.AddressOf)); break;
case OpCode.Starg_S: statement = new AssignmentStatement(this.Parameters(this.GetByte()), PopOperand()); goto done;
case OpCode.Ldloc_S: expr = this.locals[this.GetByte()]; break;
case OpCode.Ldloca_S: expr = SetType(new UnaryExpression(this.locals[this.GetByte()], NodeType.AddressOf)); break;
case OpCode.Stloc_S: statement = new AssignmentStatement(this.locals[this.GetByte()], PopOperand()); goto done;
case OpCode.Ldnull: expr = new Literal(null, CoreSystemTypes.Object); break;
case OpCode.Ldc_I4_M1: expr = new Literal(-1, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_0: expr = new Literal(0, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_1: expr = new Literal(1, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_2: expr = new Literal(2, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_3: expr = new Literal(3, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_4: expr = new Literal(4, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_5: expr = new Literal(5, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_6: expr = new Literal(6, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_7: expr = new Literal(7, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_8: expr = new Literal(8, CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4_S: expr = new Literal((int)this.GetSByte(), CoreSystemTypes.Int32); break;
case OpCode.Ldc_I4: expr = new Literal(this.GetInt32(), CoreSystemTypes.Int32); break;
case OpCode.Ldc_I8: expr = new Literal(this.GetInt64(), CoreSystemTypes.Int64); break;
case OpCode.Ldc_R4: expr = new Literal(this.GetSingle(), CoreSystemTypes.Single); break;
case OpCode.Ldc_R8: expr = new Literal(this.GetDouble(), CoreSystemTypes.Double); break;
case OpCode.Dup: statement = new ExpressionStatement(new Expression(NodeType.Dup)); goto done;
case OpCode.Pop: statement = new ExpressionStatement(new UnaryExpression(PopOperand(), NodeType.Pop)); goto done;
case OpCode.Jmp: expr = this.ParseCall(NodeType.Jmp, out isStatement); if (isStatement) goto done; break;
case OpCode.Call: expr = this.ParseCall(NodeType.Call, out isStatement); if (isStatement) goto done; break;
case OpCode.Calli: expr = this.ParseCalli(out isStatement); if (isStatement) goto done; break;
case OpCode.Ret:
Expression retVal = BodyParser.TypeIsVoid(this.method.ReturnType) ? null : PopOperand();
statement = new Return(retVal);
transferStatement = true; goto done;
case OpCode.Br_S: statement = this.ParseBranch(NodeType.Nop, 0, true, false); transferStatement = true; goto done;
case OpCode.Brfalse_S: statement = this.ParseBranch(NodeType.LogicalNot, 1, true, false); transferStatement = true; goto done;
case OpCode.Brtrue_S: statement = this.ParseBranch(NodeType.Nop, 1, true, false); transferStatement = true; goto done;
case OpCode.Beq_S: statement = this.ParseBranch(NodeType.Eq, 2, true, false); transferStatement = true; goto done;
case OpCode.Bge_S: statement = this.ParseBranch(NodeType.Ge, 2, true, false); transferStatement = true; goto done;
case OpCode.Bgt_S: statement = this.ParseBranch(NodeType.Gt, 2, true, false); transferStatement = true; goto done;
case OpCode.Ble_S: statement = this.ParseBranch(NodeType.Le, 2, true, false); transferStatement = true; goto done;
case OpCode.Blt_S: statement = this.ParseBranch(NodeType.Lt, 2, true, false); transferStatement = true; goto done;
case OpCode.Bne_Un_S: statement = this.ParseBranch(NodeType.Ne, 2, true, true); transferStatement = true; goto done;
case OpCode.Bge_Un_S: statement = this.ParseBranch(NodeType.Ge, 2, true, true); transferStatement = true; goto done;
case OpCode.Bgt_Un_S: statement = this.ParseBranch(NodeType.Gt, 2, true, true); transferStatement = true; goto done;
case OpCode.Ble_Un_S: statement = this.ParseBranch(NodeType.Le, 2, true, true); transferStatement = true; goto done;
case OpCode.Blt_Un_S: statement = this.ParseBranch(NodeType.Lt, 2, true, true); transferStatement = true; goto done;
case OpCode.Br: statement = this.ParseBranch(NodeType.Nop, 0, false, false); transferStatement = true; goto done;
case OpCode.Brfalse: statement = this.ParseBranch(NodeType.LogicalNot, 1, false, false); transferStatement = true; goto done;
case OpCode.Brtrue: statement = this.ParseBranch(NodeType.Nop, 1, false, false); transferStatement = true; goto done;
case OpCode.Beq: statement = this.ParseBranch(NodeType.Eq, 2, false, false); transferStatement = true; goto done;
case OpCode.Bge: statement = this.ParseBranch(NodeType.Ge, 2, false, false); transferStatement = true; goto done;
case OpCode.Bgt: statement = this.ParseBranch(NodeType.Gt, 2, false, false); transferStatement = true; goto done;
case OpCode.Ble: statement = this.ParseBranch(NodeType.Le, 2, false, false); transferStatement = true; goto done;
case OpCode.Blt: statement = this.ParseBranch(NodeType.Lt, 2, false, false); transferStatement = true; goto done;
case OpCode.Bne_Un: statement = this.ParseBranch(NodeType.Ne, 2, false, true); transferStatement = true; goto done;
case OpCode.Bge_Un: statement = this.ParseBranch(NodeType.Ge, 2, false, true); transferStatement = true; goto done;
case OpCode.Bgt_Un: statement = this.ParseBranch(NodeType.Gt, 2, false, true); transferStatement = true; goto done;
case OpCode.Ble_Un: statement = this.ParseBranch(NodeType.Le, 2, false, true); transferStatement = true; goto done;
case OpCode.Blt_Un: statement = this.ParseBranch(NodeType.Lt, 2, false, true); transferStatement = true; goto done;
case OpCode.Switch: statement = this.ParseSwitchInstruction(); transferStatement = true; goto done;
case OpCode.Ldind_I1: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Int8, this.isVolatile, this.alignment); break;
case OpCode.Ldind_U1: expr = new AddressDereference(PopOperand(), CoreSystemTypes.UInt8, this.isVolatile, this.alignment); break;
case OpCode.Ldind_I2: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Int16, this.isVolatile, this.alignment); break;
case OpCode.Ldind_U2: expr = new AddressDereference(PopOperand(), CoreSystemTypes.UInt16, this.isVolatile, this.alignment); break;
case OpCode.Ldind_I4: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Int32, this.isVolatile, this.alignment); break;
case OpCode.Ldind_U4: expr = new AddressDereference(PopOperand(), CoreSystemTypes.UInt32, this.isVolatile, this.alignment); break;
case OpCode.Ldind_I8: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Int64, this.isVolatile, this.alignment); break;
case OpCode.Ldind_I: expr = new AddressDereference(PopOperand(), CoreSystemTypes.IntPtr, this.isVolatile, this.alignment); break;
case OpCode.Ldind_R4: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Single, this.isVolatile, this.alignment); break;
case OpCode.Ldind_R8: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Double, this.isVolatile, this.alignment); break;
case OpCode.Ldind_Ref: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Object, this.isVolatile, this.alignment); break;
case OpCode.Stind_Ref: statement = this.ParseStoreIndirect(CoreSystemTypes.Object); goto done;
case OpCode.Stind_I1: statement = this.ParseStoreIndirect(CoreSystemTypes.Int8); goto done;
case OpCode.Stind_I2: statement = this.ParseStoreIndirect(CoreSystemTypes.Int16); goto done;
case OpCode.Stind_I4: statement = this.ParseStoreIndirect(CoreSystemTypes.Int32); goto done;
case OpCode.Stind_I8: statement = this.ParseStoreIndirect(CoreSystemTypes.Int64); goto done;
case OpCode.Stind_R4: statement = this.ParseStoreIndirect(CoreSystemTypes.Single); goto done;
case OpCode.Stind_R8: statement = this.ParseStoreIndirect(CoreSystemTypes.Double); goto done;
case OpCode.Add: expr = this.ParseBinaryOperation(NodeType.Add); break;
case OpCode.Sub: expr = this.ParseBinaryOperation(NodeType.Sub); break;
case OpCode.Mul: expr = this.ParseBinaryOperation(NodeType.Mul); break;
case OpCode.Div: expr = this.ParseBinaryOperation(NodeType.Div); break;
case OpCode.Div_Un: expr = this.ParseBinaryOperation(NodeType.Div_Un); break;
case OpCode.Rem: expr = this.ParseBinaryOperation(NodeType.Rem); break;
case OpCode.Rem_Un: expr = this.ParseBinaryOperation(NodeType.Rem_Un); break;
case OpCode.And: expr = this.ParseBinaryOperation(NodeType.And); break;
case OpCode.Or: expr = this.ParseBinaryOperation(NodeType.Or); break;
case OpCode.Xor: expr = this.ParseBinaryOperation(NodeType.Xor); break;
case OpCode.Shl: expr = this.ParseBinaryOperation(NodeType.Shl); break;
case OpCode.Shr: expr = this.ParseBinaryOperation(NodeType.Shr); break;
case OpCode.Shr_Un: expr = this.ParseBinaryOperation(NodeType.Shr_Un); break;
case OpCode.Neg: expr = this.ParseUnaryOperation(NodeType.Neg); break;
case OpCode.Not: expr = this.ParseUnaryOperation(NodeType.Not); break;
case OpCode.Conv_I1: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I1, CoreSystemTypes.Int8); break;
case OpCode.Conv_I2: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I2, CoreSystemTypes.Int16); break;
case OpCode.Conv_I4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I4, CoreSystemTypes.Int32); break;
case OpCode.Conv_I8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I8, CoreSystemTypes.Int64); break;
case OpCode.Conv_R4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_R4, CoreSystemTypes.Single); break;
case OpCode.Conv_R8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_R8, CoreSystemTypes.Double); break;
case OpCode.Conv_U4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U4, CoreSystemTypes.UInt32); break;
case OpCode.Conv_U8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U8, CoreSystemTypes.UInt64); break;
case OpCode.Callvirt: expr = this.ParseCall(NodeType.Callvirt, out isStatement); if (isStatement) goto done; break;
case OpCode.Cpobj: statement = this.ParseCopyObject(); goto done;
case OpCode.Ldobj: expr = new AddressDereference(PopOperand(), (TypeNode)this.GetMemberFromToken(), this.isVolatile, this.alignment); break;
case OpCode.Ldstr: expr = new Literal(this.GetStringFromToken(), CoreSystemTypes.String); break;
case OpCode.Newobj: expr = this.ParseConstruct(); break;
case OpCode.Castclass: expr = ParseTypeCheck(PopOperand(), (TypeNode)this.GetMemberFromToken(), NodeType.Castclass); break;
case OpCode.Isinst: expr = ParseTypeCheck(PopOperand(), (TypeNode)this.GetMemberFromToken(), NodeType.Isinst); break;
case OpCode.Conv_R_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_R_Un, CoreSystemTypes.Double); break;
case OpCode.Unbox: expr = ParseTypeCheck(PopOperand(), (TypeNode)this.GetMemberFromToken(), NodeType.Unbox); break;
case OpCode.Throw: statement = new Throw(PopOperand()); transferStatement = true; goto done;
case OpCode.Ldfld:
expr = new MemberBinding(PopOperand(), this.GetMemberFromToken(), this.isVolatile, this.alignment);
break;
case OpCode.Ldflda:
expr = SetType(new UnaryExpression(new MemberBinding(PopOperand(), this.GetMemberFromToken(), this.isVolatile, this.alignment), NodeType.AddressOf));
break;
case OpCode.Stfld: statement = this.ParseStoreField(); goto done;
case OpCode.Ldsfld: expr = new MemberBinding(null, this.GetMemberFromToken(), this.isVolatile, this.alignment); break;
case OpCode.Ldsflda: expr = SetType(new UnaryExpression(new MemberBinding(null, this.GetMemberFromToken(), this.isVolatile, this.alignment), NodeType.AddressOf)); break;
case OpCode.Stsfld: statement = new AssignmentStatement(new MemberBinding(null, this.GetMemberFromToken(), this.isVolatile, this.alignment), PopOperand()); goto done;
case OpCode.Stobj: statement = this.ParseStoreIndirect((TypeNode)this.GetMemberFromToken()); goto done;
case OpCode.Conv_Ovf_I1_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I1_Un, CoreSystemTypes.Int8); break;
case OpCode.Conv_Ovf_I2_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I2_Un, CoreSystemTypes.Int16); break;
case OpCode.Conv_Ovf_I4_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I4_Un, CoreSystemTypes.Int32); break;
case OpCode.Conv_Ovf_I8_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I8_Un, CoreSystemTypes.Int64); break;
case OpCode.Conv_Ovf_U1_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U1_Un, CoreSystemTypes.UInt8); break;
case OpCode.Conv_Ovf_U2_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U2_Un, CoreSystemTypes.UInt16); break;
case OpCode.Conv_Ovf_U4_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U4_Un, CoreSystemTypes.UInt32); break;
case OpCode.Conv_Ovf_U8_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U8_Un, CoreSystemTypes.UInt64); break;
case OpCode.Conv_Ovf_I_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I_Un, CoreSystemTypes.IntPtr); break;
case OpCode.Conv_Ovf_U_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U_Un, CoreSystemTypes.UIntPtr); break;
case OpCode.Box:
TypeNode t = (TypeNode)this.GetMemberFromToken();
TypeNode bt = t is EnumNode ? CoreSystemTypes.Enum : CoreSystemTypes.ValueType;
expr = new BinaryExpression(PopOperand(), new Literal(t, CoreSystemTypes.Type), NodeType.Box, bt); break;
case OpCode.Newarr: expr = this.ParseNewArray(); break;
case OpCode.Ldlen: expr = new UnaryExpression(PopOperand(), NodeType.Ldlen, CoreSystemTypes.UIntPtr); break;
case OpCode.Ldelema: expr = this.ParseArrayElementLoadAddress(); break;
case OpCode.Ldelem_I1:
case OpCode.Ldelem_U1:
case OpCode.Ldelem_I2:
case OpCode.Ldelem_U2:
case OpCode.Ldelem_I4:
case OpCode.Ldelem_U4:
case OpCode.Ldelem_I8:
case OpCode.Ldelem_I:
case OpCode.Ldelem_R4:
case OpCode.Ldelem_R8:
case OpCode.Ldelem_Ref: expr = this.ParseArrayElementLoad(opCode, null); break;
case OpCode.Stelem_I:
case OpCode.Stelem_I1:
case OpCode.Stelem_I2:
case OpCode.Stelem_I4:
case OpCode.Stelem_I8:
case OpCode.Stelem_R4:
case OpCode.Stelem_R8:
case OpCode.Stelem_Ref: statement = this.ParseArrayElementAssignment(opCode); goto done;
case OpCode.Ldelem: expr = this.ParseArrayElementLoad(opCode, null); break;
case OpCode.Stelem: statement = this.ParseArrayElementAssignment(opCode); goto done;
case OpCode.Unbox_Any: expr = ParseTypeCheck(PopOperand(), (TypeNode)this.GetMemberFromToken(), NodeType.UnboxAny); break;
case OpCode.Conv_Ovf_I1: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I1, CoreSystemTypes.Int8); break;
case OpCode.Conv_Ovf_U1: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U1, CoreSystemTypes.UInt8); break;
case OpCode.Conv_Ovf_I2: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I2, CoreSystemTypes.Int16); break;
case OpCode.Conv_Ovf_U2: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U2, CoreSystemTypes.UInt16); break;
case OpCode.Conv_Ovf_I4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I4, CoreSystemTypes.Int32); break;
case OpCode.Conv_Ovf_U4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U4, CoreSystemTypes.UInt32); break;
case OpCode.Conv_Ovf_I8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I8, CoreSystemTypes.Int64); break;
case OpCode.Conv_Ovf_U8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U8, CoreSystemTypes.UInt64); break;
case OpCode.Refanyval: expr = new BinaryExpression(PopOperand(), new Literal(this.GetMemberFromToken(), CoreSystemTypes.Type), NodeType.Refanyval, CoreSystemTypes.IntPtr); break;
case OpCode.Ckfinite: expr = this.ParseUnaryOperation(NodeType.Ckfinite); break;
case OpCode.Mkrefany: expr = new BinaryExpression(PopOperand(), new Literal(this.GetMemberFromToken(), CoreSystemTypes.Type), NodeType.Mkrefany, CoreSystemTypes.DynamicallyTypedReference); break;
case OpCode.Ldtoken: expr = ParseLoadRuntimeMetadataToken(); break;
case OpCode.Conv_U2: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U2, CoreSystemTypes.UInt16); break;
case OpCode.Conv_U1: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U1, CoreSystemTypes.UInt8); break;
case OpCode.Conv_I: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I, CoreSystemTypes.IntPtr); break;
case OpCode.Conv_Ovf_I: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I, CoreSystemTypes.IntPtr); break;
case OpCode.Conv_Ovf_U: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U, CoreSystemTypes.UIntPtr); break;
case OpCode.Add_Ovf: expr = this.ParseBinaryOperation(NodeType.Add_Ovf); break;
case OpCode.Add_Ovf_Un: expr = this.ParseBinaryOperation(NodeType.Add_Ovf_Un); break;
case OpCode.Mul_Ovf: expr = this.ParseBinaryOperation(NodeType.Mul_Ovf); break;
case OpCode.Mul_Ovf_Un: expr = this.ParseBinaryOperation(NodeType.Mul_Ovf_Un); break;
case OpCode.Sub_Ovf: expr = this.ParseBinaryOperation(NodeType.Sub_Ovf); break;
case OpCode.Sub_Ovf_Un: expr = this.ParseBinaryOperation(NodeType.Sub_Ovf_Un); break;
case OpCode.Endfinally: statement = new EndFinally(); transferStatement = true; goto done;
case OpCode.Leave: statement = this.ParseBranch(NodeType.Nop, 0, false, false, true); transferStatement = true; goto done;
case OpCode.Leave_S: statement = this.ParseBranch(NodeType.Nop, 0, true, false, true); transferStatement = true; goto done;
case OpCode.Stind_I: statement = this.ParseStoreIndirect(CoreSystemTypes.IntPtr); goto done;
case OpCode.Conv_U: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U, CoreSystemTypes.UIntPtr); break;
case OpCode.Arglist: expr = new Expression(NodeType.Arglist, CoreSystemTypes.ArgIterator); break;
case OpCode.Ceq: expr = this.ParseBinaryComparison(NodeType.Ceq); break;
case OpCode.Cgt: expr = this.ParseBinaryComparison(NodeType.Cgt); break;
case OpCode.Cgt_Un: expr = this.ParseBinaryComparison(NodeType.Cgt_Un); break;
case OpCode.Clt: expr = this.ParseBinaryComparison(NodeType.Clt); break;
case OpCode.Clt_Un: expr = this.ParseBinaryComparison(NodeType.Clt_Un); break;
case OpCode.Ldftn: expr = new UnaryExpression(new MemberBinding(null, this.GetMemberFromToken()), NodeType.Ldftn, CoreSystemTypes.IntPtr); break;
case OpCode.Ldvirtftn: expr = new BinaryExpression(PopOperand(), new MemberBinding(null, this.GetMemberFromToken()), NodeType.Ldvirtftn, CoreSystemTypes.IntPtr); break;
case OpCode.Ldarg: expr = this.Parameters((ushort)this.GetInt16()); break;
case OpCode.Ldarga: expr = SetType(new UnaryExpression(this.Parameters((ushort)this.GetInt16()), NodeType.AddressOf)); break;
case OpCode.Starg: statement = new AssignmentStatement(this.Parameters((ushort)this.GetInt16()), PopOperand()); goto done;
case OpCode.Ldloc: expr = this.locals[(ushort)this.GetInt16()]; break;
case OpCode.Ldloca: expr = SetType(new UnaryExpression(this.locals[(ushort)this.GetInt16()], NodeType.AddressOf)); break;
case OpCode.Stloc: statement = new AssignmentStatement(this.locals[(ushort)this.GetInt16()], PopOperand()); goto done;
case OpCode.Localloc: expr = new UnaryExpression(PopOperand(), NodeType.Localloc, CoreSystemTypes.Void); break;
case OpCode.Endfilter: statement = new EndFilter(PopOperand()); transferStatement = true; goto done;
case OpCode.Unaligned_: this.alignment = this.GetByte(); continue;
case OpCode.Volatile_: this.isVolatile = true; continue;
case OpCode.Tail_: this.isTailCall = true; continue;
case OpCode.Initobj: statement = this.ParseInitObject(); goto done;
case OpCode.Constrained_: this.constraint = this.GetMemberFromToken() as TypeNode; continue;
case OpCode.Cpblk: expr = this.ParseTernaryOperation(NodeType.Cpblk); goto done;
case OpCode.Initblk: expr = this.ParseTernaryOperation(NodeType.Initblk); goto done;
case OpCode.Rethrow: statement = new Throw(null); statement.NodeType = NodeType.Rethrow; transferStatement = true; goto done;
case OpCode.Sizeof: expr = new UnaryExpression(new Literal(this.GetMemberFromToken(), CoreSystemTypes.Type), NodeType.Sizeof, CoreSystemTypes.Int32); break;
case OpCode.Refanytype: expr = new UnaryExpression(PopOperand(), NodeType.Refanytype, CoreSystemTypes.RuntimeTypeHandle); break;
case OpCode.Readonly_: this.isReadOnly = true; continue;
default: throw new InvalidMetadataException(ExceptionStrings.UnknownOpCode);
}
if (this.blockMap[this.counter+1] != null){
transferStatement = true; //Falls through to the next basic block, so implicitly a "transfer" statement
goto done;
}
//^ assume expr != null;
#if FxCop
expr.sourceContext = sourceContext;
#endif
#if FxCop || ILOFFSETS
expr.ILOffset = this.ilOffset;
#endif
this.operandStack.Push(expr);
this.isReadOnly = false;
this.isVolatile = false;
this.isTailCall = false;
this.alignment = -1;
}
done:
for (int i = 0; i <= this.operandStack.top; i++){
Expression e = this.operandStack.elements[i];
//^ assume e != null;
Statement s = new ExpressionStatement(e);
#if FxCop
s.SourceContext = this.sourceContext;
#endif
#if FxCop || ILOFFSETS
s.ILOffset = this.ilOffset;
#endif
statementList.Add(s);
}
this.operandStack.top = -1;
if (statement == null) {
statement = new ExpressionStatement(expr);
#if FxCop
expr.sourceContext = this.sourceContext;
#endif
#if FxCop || ILOFFSETS
expr.ILOffset = this.ilOffset;
#endif
}
statement.SourceContext = sourceContext;
#if FxCop || ILOFFSETS
statement.ILOffset = this.ilOffset;
#endif
#if ILOFFSETS
this.lastSourceContext = sourceContext;
#endif
statementList.Add(statement);
if (transferStatement) return true;
return this.blockMap[this.counter+1] != null;
}
// ExpressionStatement
public override bool Walk(ExpressionStatement node)
{
return(false);
}
// ExpressionStatement
public virtual bool Walk(ExpressionStatement node) { return true; }
public override void PostWalk(ExpressionStatement node)
{
}
public virtual void VisitExpressionStatement (ExpressionStatement expressionStatement)
{
VisitChildren (expressionStatement);
}
// ExpressionStatement
public override bool Walk(ExpressionStatement node)
{
return(Location >= node.StartIndex && Location <= node.EndIndex);
}
public override object VisitBlockStatement(BlockStatement blockStatement, object data)
{
base.VisitBlockStatement(blockStatement, data);
foreach (ExpressionStatement stmt in blockStatement.Statements.OfType <ExpressionStatement>().ToArray())
{
Match displayClassAssignmentMatch = displayClassAssignmentPattern.Match(stmt);
if (displayClassAssignmentMatch == null)
{
continue;
}
ILVariable variable = displayClassAssignmentMatch.Get("variable").Single().Annotation <ILVariable>();
if (variable == null)
{
continue;
}
TypeDefinition type = variable.Type.ResolveWithinSameModule();
if (!IsPotentialClosure(context, type))
{
continue;
}
if (displayClassAssignmentMatch.Get("type").Single().Annotation <TypeReference>().ResolveWithinSameModule() != type)
{
continue;
}
// Looks like we found a display class creation. Now let's verify that the variable is used only for field accesses:
bool ok = true;
foreach (var identExpr in blockStatement.Descendants.OfType <IdentifierExpression>())
{
if (identExpr.Identifier == variable.Name && identExpr != displayClassAssignmentMatch.Get("variable").Single())
{
if (!(identExpr.Parent is MemberReferenceExpression && identExpr.Parent.Annotation <FieldReference>() != null))
{
ok = false;
}
}
}
if (!ok)
{
continue;
}
Dictionary <FieldReference, AstNode> dict = new Dictionary <FieldReference, AstNode>();
// Delete the variable declaration statement:
AstNode cur = stmt.NextSibling;
stmt.Remove();
if (blockStatement.Parent.NodeType == NodeType.Member || blockStatement.Parent is Accessor)
{
// Delete any following statements as long as they assign parameters to the display class
// Do parameter handling only for closures created in the top scope (direct child of method/accessor)
List <ILVariable> parameterOccurrances = blockStatement.Descendants.OfType <IdentifierExpression>()
.Select(n => n.Annotation <ILVariable>()).Where(p => p != null && p.IsParameter).ToList();
AstNode next;
for (; cur != null; cur = next)
{
next = cur.NextSibling;
// Test for the pattern:
// "variableName.MemberName = right;"
ExpressionStatement closureFieldAssignmentPattern = new ExpressionStatement(
new AssignmentExpression(
new NamedNode("left", new MemberReferenceExpression {
Target = new IdentifierExpression(variable.Name)
}),
new AnyNode("right")
)
);
Match m = closureFieldAssignmentPattern.Match(cur);
if (m != null)
{
AstNode right = m.Get("right").Single();
bool isParameter = false;
if (right is ThisReferenceExpression)
{
isParameter = true;
}
else if (right is IdentifierExpression)
{
// handle parameters only if the whole method contains no other occurrance except for 'right'
ILVariable param = right.Annotation <ILVariable>();
isParameter = param.IsParameter && parameterOccurrances.Count(c => c == param) == 1;
}
if (isParameter)
{
dict[m.Get <MemberReferenceExpression>("left").Single().Annotation <FieldReference>().ResolveWithinSameModule()] = right;
cur.Remove();
}
else
{
break;
}
}
else
{
break;
}
}
}
// Now create variables for all fields of the display class (except for those that we already handled as parameters)
List <Tuple <AstType, string> > variablesToDeclare = new List <Tuple <AstType, string> >();
foreach (FieldDefinition field in type.Fields)
{
if (dict.ContainsKey(field))
{
continue;
}
variablesToDeclare.Add(Tuple.Create(AstBuilder.ConvertType(field.FieldType, field), field.Name));
dict[field] = new IdentifierExpression(field.Name);
}
// Now figure out where the closure was accessed and use the simpler replacement expression there:
foreach (var identExpr in blockStatement.Descendants.OfType <IdentifierExpression>())
{
if (identExpr.Identifier == variable.Name)
{
MemberReferenceExpression mre = (MemberReferenceExpression)identExpr.Parent;
AstNode replacement;
if (dict.TryGetValue(mre.Annotation <FieldReference>().ResolveWithinSameModule(), out replacement))
{
mre.ReplaceWith(replacement.Clone());
}
}
}
// Now insert the variable declarations (we can do this after the replacements only so that the scope detection works):
Statement insertionPoint = blockStatement.Statements.FirstOrDefault();
foreach (var tuple in variablesToDeclare)
{
var newVarDecl = new VariableDeclarationStatement(tuple.Item1, tuple.Item2);
newVarDecl.Variables.Single().AddAnnotation(new CapturedVariableAnnotation());
blockStatement.Statements.InsertBefore(insertionPoint, newVarDecl);
}
}
return(null);
}
// ExpressionStatement
public virtual bool Walk(ExpressionStatement node)
{
return(true);
}
static bool CanMoveVariableUseIntoSubBlock(Statement stmt, string variableName, bool allowPassIntoLoops)
{
if (!allowPassIntoLoops && (stmt is ForStatement || stmt is ForeachStatement || stmt is DoWhileStatement || stmt is WhileStatement))
{
return(false);
}
ForStatement forStatement = stmt as ForStatement;
if (forStatement != null && forStatement.Initializers.Count == 1)
{
// for-statement is special case: we can move variable declarations into the initializer
ExpressionStatement es = forStatement.Initializers.Single() as ExpressionStatement;
if (es != null)
{
AssignmentExpression ae = es.Expression as AssignmentExpression;
if (ae != null && ae.Operator == AssignmentOperatorType.Assign)
{
IdentifierExpression ident = ae.Left as IdentifierExpression;
if (ident != null && ident.Identifier == variableName)
{
return(!UsesVariable(ae.Right, variableName));
}
}
}
}
UsingStatement usingStatement = stmt as UsingStatement;
if (usingStatement != null)
{
// using-statement is special case: we can move variable declarations into the initializer
AssignmentExpression ae = usingStatement.ResourceAcquisition as AssignmentExpression;
if (ae != null && ae.Operator == AssignmentOperatorType.Assign)
{
IdentifierExpression ident = ae.Left as IdentifierExpression;
if (ident != null && ident.Identifier == variableName)
{
return(!UsesVariable(ae.Right, variableName));
}
}
}
IfElseStatement ies = stmt as IfElseStatement;
if (ies != null)
{
foreach (var child in IfElseChainChildren(ies))
{
if (!(child is BlockStatement) && UsesVariable(child, variableName))
{
return(false);
}
}
return(true);
}
// We can move the variable into a sub-block only if the variable is used in only that sub-block (and not in expressions such as the loop condition)
for (AstNode child = stmt.FirstChild; child != null; child = child.NextSibling)
{
if (!(child is BlockStatement) && UsesVariable(child, variableName))
{
if (HasNestedBlocks(child))
{
// catch clauses/switch sections can contain nested blocks
for (AstNode grandchild = child.FirstChild; grandchild != null; grandchild = grandchild.NextSibling)
{
if (!(grandchild is BlockStatement) && UsesVariable(grandchild, variableName))
{
return(false);
}
}
}
else
{
return(false);
}
}
}
return(true);
}
public virtual void PostWalk(ExpressionStatement node)
{
}
void ConvertForStatement(ForStatement forStatement)
{
// ForStatement -> ForNextStatement when for-loop is simple
// only the following forms of the for-statement are allowed:
// for (TypeReference name = start; name < oneAfterEnd; name += step)
// for (name = start; name < oneAfterEnd; name += step)
// for (TypeReference name = start; name <= end; name += step)
// for (name = start; name <= end; name += step)
// for (TypeReference name = start; name > oneAfterEnd; name -= step)
// for (name = start; name > oneAfterEnd; name -= step)
// for (TypeReference name = start; name >= end; name -= step)
// for (name = start; name >= end; name -= step)
// check if the form is valid and collect TypeReference, name, start, end and step
if (forStatement.Initializers.Count != 1)
{
return;
}
if (forStatement.Iterator.Count != 1)
{
return;
}
ExpressionStatement statement = forStatement.Iterator[0] as ExpressionStatement;
if (statement == null)
{
return;
}
AssignmentExpression iterator = statement.Expression as AssignmentExpression;
if (iterator == null || (iterator.Op != AssignmentOperatorType.Add && iterator.Op != AssignmentOperatorType.Subtract))
{
return;
}
IdentifierExpression iteratorIdentifier = iterator.Left as IdentifierExpression;
if (iteratorIdentifier == null)
{
return;
}
PrimitiveExpression stepExpression = iterator.Right as PrimitiveExpression;
if (stepExpression == null || !(stepExpression.Value is int))
{
return;
}
int step = (int)stepExpression.Value;
if (iterator.Op == AssignmentOperatorType.Subtract)
{
step = -step;
}
BinaryOperatorExpression condition = forStatement.Condition as BinaryOperatorExpression;
if (condition == null || !(condition.Left is IdentifierExpression))
{
return;
}
if ((condition.Left as IdentifierExpression).Identifier != iteratorIdentifier.Identifier)
{
return;
}
Expression end;
if (iterator.Op == AssignmentOperatorType.Subtract)
{
if (condition.Op == BinaryOperatorType.GreaterThanOrEqual)
{
end = condition.Right;
}
else if (condition.Op == BinaryOperatorType.GreaterThan)
{
end = Expression.AddInteger(condition.Right, 1);
}
else
{
return;
}
}
else
{
if (condition.Op == BinaryOperatorType.LessThanOrEqual)
{
end = condition.Right;
}
else if (condition.Op == BinaryOperatorType.LessThan)
{
end = Expression.AddInteger(condition.Right, -1);
}
else
{
return;
}
}
Expression start;
TypeReference typeReference = null;
LocalVariableDeclaration varDecl = forStatement.Initializers[0] as LocalVariableDeclaration;
if (varDecl != null)
{
if (varDecl.Variables.Count != 1 ||
varDecl.Variables[0].Name != iteratorIdentifier.Identifier ||
varDecl.Variables[0].Initializer == null)
{
return;
}
typeReference = varDecl.GetTypeForVariable(0);
start = varDecl.Variables[0].Initializer;
}
else
{
statement = forStatement.Initializers[0] as ExpressionStatement;
if (statement == null)
{
return;
}
AssignmentExpression assign = statement.Expression as AssignmentExpression;
if (assign == null || assign.Op != AssignmentOperatorType.Assign)
{
return;
}
if (!(assign.Left is IdentifierExpression))
{
return;
}
if ((assign.Left as IdentifierExpression).Identifier != iteratorIdentifier.Identifier)
{
return;
}
start = assign.Right;
}
ReplaceCurrentNode(
new ForNextStatement {
TypeReference = typeReference,
VariableName = iteratorIdentifier.Identifier,
Start = start,
End = end,
Step = (step == 1) ? null : new PrimitiveExpression(step, step.ToString(System.Globalization.NumberFormatInfo.InvariantInfo)),
EmbeddedStatement = forStatement.EmbeddedStatement
});
}
public override bool Walk(ExpressionStatement node)
{
UpdateChildRanges(node);
return(base.Walk(node));
}
// ExpressionStatement
public override bool Walk(ExpressionStatement node)
{
return(ShouldWalkWorker(node));
}
public override void PostWalk(ExpressionStatement node)
{
PostWalkWorker(node);
}
public override bool Enter(ExpressionStatement node)
{
Print("ExpressionStatement");
level++;
return true;
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)
{
var invocationType = invocation;
Trace.Assert(MethodToOverride.IsGenericMethod == invocationType.IsGenericTypeDefinition);
var genericArguments = Type.EmptyTypes;
var constructor = invocation.GetConstructors()[0];
Expression proxiedMethodTokenExpression;
if (MethodToOverride.IsGenericMethod)
{
// bind generic method arguments to invocation's type arguments
genericArguments = emitter.MethodBuilder.GetGenericArguments();
invocationType = invocationType.MakeGenericType(genericArguments);
constructor = TypeBuilder.GetConstructor(invocationType, constructor);
// Not in the cache: generic method
proxiedMethodTokenExpression = new MethodTokenExpression(MethodToOverride.MakeGenericMethod(genericArguments));
}
else
{
var proxiedMethodToken = @class.CreateStaticField(namingScope.GetUniqueName("token_" + MethodToOverride.Name),
typeof(MethodInfo));
@class.ClassConstructor.CodeBuilder.AddStatement(new AssignStatement(proxiedMethodToken,
new MethodTokenExpression(MethodToOverride)));
proxiedMethodTokenExpression = proxiedMethodToken.ToExpression();
}
var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments);
var arguments = GetCtorArguments(@class, namingScope, proxiedMethodTokenExpression,
dereferencedArguments);
var ctorArguments = ModifyArguments(@class, arguments);
var invocationLocal = emitter.CodeBuilder.DeclareLocal(invocationType);
emitter.CodeBuilder.AddStatement(new AssignStatement(invocationLocal,
new NewInstanceExpression(constructor, ctorArguments)));
if (MethodToOverride.ContainsGenericParameters)
{
EmitLoadGenricMethodArguments(emitter, MethodToOverride.MakeGenericMethod(genericArguments), invocationLocal);
}
var proceed = new ExpressionStatement(new MethodInvocationExpression(invocationLocal, InvocationMethods.Proceed));
emitter.CodeBuilder.AddStatement(proceed);
GeneratorUtil.CopyOutAndRefParameters(dereferencedArguments, invocationLocal, MethodToOverride, emitter);
if (MethodToOverride.ReturnType != typeof(void))
{
// Emit code to return with cast from ReturnValue
var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue);
emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal)));
}
else
{
emitter.CodeBuilder.AddStatement(new ReturnStatement());
}
return(emitter);
}
public override object VisitBlockStatement(BlockStatement blockStatement, object data)
{
base.VisitBlockStatement(blockStatement, data);
foreach (VariableDeclarationStatement stmt in blockStatement.Statements.OfType<VariableDeclarationStatement>()) {
if (stmt.Variables.Count() != 1)
continue;
var variable = stmt.Variables.Single();
TypeDefinition type = stmt.Type.Annotation<TypeDefinition>();
if (!IsPotentialClosure(type))
continue;
ObjectCreateExpression oce = variable.Initializer as ObjectCreateExpression;
if (oce == null || oce.Type.Annotation<TypeReference>() != type || oce.Arguments.Any() || !oce.Initializer.IsNull)
continue;
// Looks like we found a display class creation. Now let's verify that the variable is used only for field accesses:
bool ok = true;
foreach (var identExpr in blockStatement.Descendants.OfType<IdentifierExpression>()) {
if (identExpr.Identifier == variable.Name) {
if (!(identExpr.Parent is MemberReferenceExpression && identExpr.Parent.Annotation<FieldReference>() != null))
ok = false;
}
}
if (!ok)
continue;
Dictionary<FieldReference, AstNode> dict = new Dictionary<FieldReference, AstNode>();
// Delete the variable declaration statement:
AstNode cur = stmt.NextSibling;
stmt.Remove();
if (blockStatement.Parent.NodeType == NodeType.Member || blockStatement.Parent is Accessor) {
// Delete any following statements as long as they assign parameters to the display class
// Do parameter handling only for closures created in the top scope (direct child of method/accessor)
List<ParameterReference> parameterOccurrances = blockStatement.Descendants.OfType<IdentifierExpression>()
.Select(n => n.Annotation<ParameterReference>()).Where(p => p != null).ToList();
AstNode next;
for (; cur != null; cur = next) {
next = cur.NextSibling;
// Test for the pattern:
// "variableName.MemberName = right;"
ExpressionStatement closureFieldAssignmentPattern = new ExpressionStatement(
new AssignmentExpression(
new NamedNode("left", new MemberReferenceExpression { Target = new IdentifierExpression(variable.Name) }),
new AnyNode("right")
)
);
Match m = closureFieldAssignmentPattern.Match(cur);
if (m != null) {
AstNode right = m.Get("right").Single();
bool isParameter = false;
if (right is ThisReferenceExpression) {
isParameter = true;
} else if (right is IdentifierExpression) {
// handle parameters only if the whole method contains no other occurrance except for 'right'
ParameterReference param = right.Annotation<ParameterReference>();
isParameter = parameterOccurrances.Count(c => c == param) == 1;
}
if (isParameter) {
dict[m.Get<MemberReferenceExpression>("left").Single().Annotation<FieldReference>()] = right;
cur.Remove();
} else {
break;
}
} else {
break;
}
}
}
// Now create variables for all fields of the display class (except for those that we already handled as parameters)
List<Tuple<AstType, string>> variablesToDeclare = new List<Tuple<AstType, string>>();
foreach (FieldDefinition field in type.Fields) {
if (dict.ContainsKey(field))
continue;
variablesToDeclare.Add(Tuple.Create(AstBuilder.ConvertType(field.FieldType, field), field.Name));
dict[field] = new IdentifierExpression(field.Name);
}
// Now figure out where the closure was accessed and use the simpler replacement expression there:
foreach (var identExpr in blockStatement.Descendants.OfType<IdentifierExpression>()) {
if (identExpr.Identifier == variable.Name) {
MemberReferenceExpression mre = (MemberReferenceExpression)identExpr.Parent;
AstNode replacement;
if (dict.TryGetValue(mre.Annotation<FieldReference>(), out replacement)) {
mre.ReplaceWith(replacement.Clone());
}
}
}
// Now insert the variable declarations (we can do this after the replacements only so that the scope detection works):
foreach (var tuple in variablesToDeclare) {
var newVarDecl = DeclareVariableInSmallestScope.DeclareVariable(blockStatement, tuple.Item1, tuple.Item2, allowPassIntoLoops: false);
if (newVarDecl != null)
newVarDecl.Variables.Single().AddAnnotation(new CapturedVariableAnnotation());
}
}
return null;
}
public virtual void VisitExpressionStatement(ExpressionStatement node)
{
Visit(node.Expression);
}
protected internal virtual void PostWalk(ExpressionStatement node) { }
public override bool Walk(ExpressionStatement node)
{
return(base.Walk(node));
}
public virtual Statement VisitExpressionStatement(ExpressionStatement statement, ExpressionStatement changes, ExpressionStatement deletions, ExpressionStatement insertions){
this.UpdateSourceContext(statement, changes);
if (statement == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
statement.Expression = this.VisitExpression(statement.Expression, changes.Expression, deletions.Expression, insertions.Expression);
}
}else if (deletions != null)
return null;
return statement;
}
public override IEnumerable <Expression> VisitExpressionStatement(ExpressionStatement expressionStatement)
{
yield return(expressionStatement.Expression);
}
// IMPORTANT NOTE:
// The grammar consists of a few LALR(1) conflicts. These issues are, however, correctly handled, due to the fact that the grammar
// is defined in a specific order making the already added parser actions have precedence over the other.
//
// Known conflicts that are correctly handled:
//
// - ELSE: Shift/Reduce conflict Dangling ELSE problem. Lots of articles are around on the internet.
// The shift action is taken here.
//
// - CLOSE_PARENS: Shift/Reduce conflict. This is due to the fact that the explicit cast expression is like the parenthesized
// expression. The shift action is taken here.
//
// - STAR: Reduce/Reduce conflict, between VariableType -> TypeNameExpression and PrimaryExpression -> TypeNameExpression,
// due to the fact variable types can have '*', and look therefore like a binary operator expression.
// The first reduce action is taken here.
public CSharpGrammar()
{
// Please let me know if there is a better way of tidying this :s
TokenMapping.Add((int)ERROR, Error);
#region Definitions to use later
var statementList = new GrammarDefinition("StatementList");
var statementListOptional = new GrammarDefinition("StatementListOptional",
rule: null
| statementList);
var blockStatement = new GrammarDefinition("BlockStatement");
var variableDeclarator = new GrammarDefinition("VariableDeclarator");
var variableDeclaratorList = new GrammarDefinition("VariableDeclaratorList");
variableDeclaratorList.Rule = variableDeclarator
| variableDeclaratorList
+ ToElement(COMMA)
+ variableDeclarator;
var variableDeclaration = new GrammarDefinition("VariableDeclaration");
var variableInitializer = new GrammarDefinition("VariableInitializer");
var arrayInitializer = new GrammarDefinition("ArrayInitializer");
var arrayInitializerOptional = new GrammarDefinition("ArrayInitializerOptional",
rule: null | arrayInitializer);
var identifierInsideBody = new GrammarDefinition("IdentifierInsideBody",
rule: ToElement(IDENTIFIER),
createNode: node => ToIdentifier(node.Children[0].Result));
var identifierInsideBodyOptional = new GrammarDefinition("IdentifierInsideBodyOptional",
rule: null | identifierInsideBody);
variableDeclarator.Rule = identifierInsideBody
| identifierInsideBody
+ ToElement(EQUALS)
+ variableInitializer;
variableDeclarator.ComputeResult = node =>
{
var result = new VariableDeclarator((Identifier) node.Children[0].Result);
if (node.Children.Count > 1)
{
result.OperatorToken = (AstToken) node.Children[1].Result;
result.Value = (Expression) node.Children[2].Result;
}
return result;
};
var typeReference = new GrammarDefinition("TypeReference");
var identifierExpression = new GrammarDefinition("IdentifierExpression",
rule: identifierInsideBody,
createNode: node => new IdentifierExpression((Identifier) node.Children[0].Result));
var usingDirectiveListOptional = new GrammarDefinition("UsingDirectiveListOptional");
#endregion
#region Type References
var namespaceOrTypeExpression = new GrammarDefinition("NamespaceOrTypeExpression");
namespaceOrTypeExpression.Rule = identifierExpression |
namespaceOrTypeExpression
+ ToElement(DOT)
+ ToElement(IDENTIFIER);
namespaceOrTypeExpression.ComputeResult = node =>
{
if (node.Children.Count == 1)
return ToTypeReference((IConvertibleToType) node.Children[0].Result);
var result = new MemberTypeReference();
result.Target = (TypeReference) node.Children[0].Result;
result.AddChild(AstNodeTitles.Accessor, node.Children[1].Result);
result.Identifier = ToIdentifier(node.Children[2].Result);
return result;
};
ComputeResultDelegate createPrimitiveTypeExpression = node =>
{
if (node.Children[0].Result is PrimitiveTypeReference)
return node.Children[0].Result;
return new PrimitiveTypeReference
{
Identifier = ToIdentifier(node.Children[0].Result),
PrimitiveType = CSharpLanguage.PrimitiveTypeFromString(((AstToken) node.Children[0].Result).Value)
};
};
var integralType = new GrammarDefinition("IntegralType",
rule: ToElement(SBYTE)
| ToElement(BYTE)
| ToElement(SHORT)
| ToElement(USHORT)
| ToElement(INT)
| ToElement(UINT)
| ToElement(LONG)
| ToElement(ULONG)
| ToElement(CHAR),
createNode: createPrimitiveTypeExpression);
var primitiveType = new GrammarDefinition("PrimitiveTypeExpression",
rule: ToElement(OBJECT)
| ToElement(STRING)
| ToElement(BOOL)
| ToElement(DECIMAL)
| ToElement(FLOAT)
| ToElement(DOUBLE)
| ToElement(VOID)
| integralType,
createNode: createPrimitiveTypeExpression);
var dimensionSeparators = new GrammarDefinition("DimensionSeparators");
dimensionSeparators.Rule = ToElement(COMMA)
| dimensionSeparators + ToElement(COMMA);
var rankSpecifier = new GrammarDefinition("RankSpecifier",
rule: ToElement(OPEN_BRACKET) + ToElement(CLOSE_BRACKET)
| ToElement(OPEN_BRACKET) + dimensionSeparators
+ ToElement(CLOSE_BRACKET),
createNode: node =>
{
var result = new ArrayTypeRankSpecifier();
result.LeftBracket = (AstToken) node.Children[0].Result;
if (node.Children.Count == 3)
{
foreach (var dimensionSeparator in node.Children[1].GetAllNodesFromListDefinition()
.Select(x => x.Result))
{
result.Dimensions++;
result.AddChild(AstNodeTitles.ElementSeparator, dimensionSeparator);
}
}
result.RightBracket = (AstToken) node.Children[node.Children.Count - 1].Result;
return result;
});
var arrayType = new GrammarDefinition("ArrayType",
rule: typeReference
+ rankSpecifier,
createNode: node => new ArrayTypeReference()
{
BaseType = (TypeReference) node.Children[0].Result,
RankSpecifier = (ArrayTypeRankSpecifier) node.Children[1].Result
});
var pointerType = new GrammarDefinition("PointerType",
rule: typeReference
+ ToElement(STAR),
createNode: node => new PointerTypeReference()
{
BaseType = (TypeReference) node.Children[0].Result,
PointerToken = (AstToken) node.Children[1].Result
});
var typeExpression = new GrammarDefinition("TypeExpression",
rule: namespaceOrTypeExpression
| primitiveType);
typeReference.Rule = typeExpression
| arrayType
| pointerType
;
#endregion
#region Expressions
ComputeResultDelegate createBinaryOperatorExpression = node =>
{
if (node.Children.Count == 1)
return node.Children[0].Result;
var result = new BinaryOperatorExpression();
result.Left = (Expression) node.Children[0].Result;
var operatorToken = (AstToken) (node.Children[1].Result ?? node.Children[1].Children[0].Result);
result.Operator = CSharpLanguage.BinaryOperatorFromString(operatorToken.Value);
result.OperatorToken = (AstToken) operatorToken;
result.Right = (Expression) node.Children[2].Result;
return result;
};
var expression = new GrammarDefinition("Expression");
var expressionOptional = new GrammarDefinition("ExpressionOptional",
rule: null
| expression);
var primaryExpression = new GrammarDefinition("PrimaryExpression");
var primitiveExpression = new GrammarDefinition("PrimitiveExpression",
rule: ToElement(LITERAL)
| ToElement(TRUE)
| ToElement(FALSE)
| ToElement(NULL),
createNode: node =>
{
object interpretedValue;
node.Children[0].Result.UserData.TryGetValue("InterpretedValue", out interpretedValue);
var result = new PrimitiveExpression(interpretedValue, ((AstToken) node.Children[0].Result).Value, node.Children[0].Range);
return result;
});
var parenthesizedExpression = new GrammarDefinition("ParenthesizedExpression",
rule: ToElement(OPEN_PARENS)
+ expression
+ ToElement(CLOSE_PARENS)
| ToElement(OPEN_PARENS)
+ Error
+ ToElement(CLOSE_PARENS),
createNode: node => new ParenthesizedExpression
{
LeftParenthese = (AstToken) node.Children[0].Result,
Expression = (Expression) node.Children[1].Result,
RightParenthese = (AstToken) node.Children[2].Result,
});
var memberAccessorOperator = new GrammarDefinition("MemberAccessorOperator",
rule: ToElement(DOT)
| ToElement(OP_PTR)
| ToElement(INTERR_OPERATOR));
var memberReferenceExpression = new GrammarDefinition("MemberReferenceExpression",
rule: primaryExpression + memberAccessorOperator + identifierInsideBody
| primaryExpression + memberAccessorOperator + Error,
createNode: node => new MemberReferenceExpression
{
Target =
(Expression)
((IConvertibleToExpression) node.Children[0].Result).ToExpression().Remove(),
Accessor = CSharpLanguage.AccessorFromString(((AstToken) node.Children[1].Children[0].Result).Value),
AccessorToken = (AstToken) node.Children[1].Children[0].Result,
Identifier = (Identifier) node.Children[2].Result
});
var argument = new GrammarDefinition("Argument",
rule: expression
| ToElement(REF) + expression
| ToElement(OUT) + expression,
createNode: node =>
{
if (node.Children.Count > 1)
{
return new DirectionExpression()
{
DirectionToken = (AstToken) node.Children[0].Result,
Direction = CSharpLanguage.DirectionFromString(((AstToken) node.Children[0].Result).Value),
Expression = (Expression) node.Children[1].Result
};
}
return node.Children[0].Result;
});
var argumentList = new GrammarDefinition("ArgumentList");
argumentList.Rule = argument
| argumentList + ToElement(COMMA) + argument;
var argumentListOptional = new GrammarDefinition("ArgumentListOptional",
rule: null | argumentList);
var invocationExpression = new GrammarDefinition("InvocationExpression",
rule: primaryExpression
+ ToElement(OPEN_PARENS)
+ argumentListOptional
+ ToElement(CLOSE_PARENS),
createNode: node =>
{
var result = new InvocationExpression()
{
Target = (Expression) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
};
if (node.Children[2].HasChildren)
{
foreach (var subNode in node.Children[2].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Arguments.Add((Expression) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[3].Result;
return result;
});
var indexerExpression = new GrammarDefinition("IndexerExpression",
rule: primaryExpression
+ ToElement(OPEN_BRACKET_EXPR)
+ argumentList
+ ToElement(CLOSE_BRACKET),
createNode: node =>
{
var result = new IndexerExpression()
{
Target = (Expression) node.Children[0].Result,
LeftBracket = (AstToken) node.Children[1].Result,
};
foreach (var subNode in node.Children[2].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Indices.Add((Expression) subNode);
}
result.RightBracket = (AstToken) node.Children[3].Result;
return result;
});
var createObjectExpression = new GrammarDefinition("CreateObjectExpression",
rule: ToElement(NEW)
+ typeReference
+ ToElement(OPEN_PARENS)
+ argumentListOptional
+ ToElement(CLOSE_PARENS)
+ arrayInitializerOptional
| ToElement(NEW)
+ namespaceOrTypeExpression
+ arrayInitializer,
createNode: node =>
{
var result = new CreateObjectExpression();
result.NewKeyword = (AstToken) node.Children[0].Result;
result.Type = (TypeReference) node.Children[1].Result;
if (node.Children.Count == 6)
{
result.LeftParenthese = (AstToken) node.Children[2].Result;
if (node.Children[3].HasChildren)
{
foreach (var subNode in node.Children[3].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Arguments.Add((Expression) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[4].Result;
}
var initializerNode = node.Children[node.Children.Count - 1];
if (initializerNode.HasChildren)
result.Initializer = (ArrayInitializer) initializerNode.Result;
return result;
});
var createArrayExpression = new GrammarDefinition("CreateArrayExpression",
rule: ToElement(NEW)
+ rankSpecifier
+ arrayInitializer
| ToElement(NEW)
+ typeReference
+ rankSpecifier
+ arrayInitializer
| ToElement(NEW)
+ typeReference
+ ToElement(OPEN_BRACKET_EXPR)
+ argumentList
+ ToElement(CLOSE_BRACKET)
+ arrayInitializerOptional
,
createNode: node =>
{
var result = new CreateArrayExpression();
result.NewKeyword = (AstToken) node.Children[0].Result;
switch (node.Children.Count)
{
case 3:
{
var rankSpecifierNode = (ArrayTypeRankSpecifier) node.Children[1].Result;
result.LeftBracket = (AstToken) rankSpecifierNode.LeftBracket.Remove();
result.RightBracket = (AstToken) rankSpecifierNode.RightBracket.Remove();
break;
}
case 4:
{
result.Type = (TypeReference) node.Children[1].Result;
var rankSpecifierNode = (ArrayTypeRankSpecifier) node.Children[2].Result;
result.LeftBracket = (AstToken) rankSpecifierNode.LeftBracket.Remove();
result.RightBracket = (AstToken) rankSpecifierNode.RightBracket.Remove();
break;
}
case 6:
{
result.Type = (TypeReference) node.Children[1].Result;
result.LeftBracket = (AstToken) node.Children[2].Result;
if (node.Children[3].HasChildren)
{
foreach (var subNode in node.Children[3].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Arguments.Add((Expression) subNode);
}
}
result.RightBracket = (AstToken) node.Children[4].Result;
break;
}
}
var initializerNode = node.Children[node.Children.Count - 1];
if (initializerNode.HasChildren)
result.Initializer = (ArrayInitializer) initializerNode.Result;
return result;
});
var primitiveTypeExpression = new GrammarDefinition("PrimitiveTypeExpression",
rule: primitiveType,
createNode: node => ((IConvertibleToExpression) node.Children[0].Result).ToExpression());
var typeNameExpression = new GrammarDefinition("TypeNameExpression",
rule: identifierExpression
| memberReferenceExpression
| primitiveTypeExpression);
var thisExpression = new GrammarDefinition("ThisExpression",
rule: ToElement(THIS),
createNode: node => new ThisReferenceExpression()
{
ThisKeywordToken = (AstToken) node.Children[0].Result,
});
var baseExpression = new GrammarDefinition("BaseExpression",
rule: ToElement(BASE),
createNode: node => new BaseReferenceExpression()
{
BaseKeywordToken = (AstToken) node.Children[0].Result,
});
var typeofExpression = new GrammarDefinition("TypeOfExpression",
rule: ToElement(TYPEOF) + ToElement(OPEN_PARENS) + typeReference
+ ToElement(CLOSE_PARENS),
createNode: node => new GetTypeExpression()
{
GetTypeKeywordToken = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetType = (TypeReference) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var defaultExpression = new GrammarDefinition("DefaultExpression",
rule: ToElement(DEFAULT)
+ ToElement(OPEN_PARENS)
+ typeReference
+ ToElement(CLOSE_PARENS),
createNode: node => new DefaultExpression()
{
KeywordToken = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetType = (TypeReference) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var sizeofExpression = new GrammarDefinition("SizeOfExpression",
rule: ToElement(SIZEOF) + ToElement(OPEN_PARENS) + typeReference
+ ToElement(CLOSE_PARENS),
createNode: node => new SizeOfExpression()
{
SizeofKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetType = (TypeReference) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var checkedExpression = new GrammarDefinition("CheckedExpression",
rule:
ToElement(CHECKED) + ToElement(OPEN_PARENS) + expression +
ToElement(CLOSE_PARENS),
createNode: node => new CheckedExpression()
{
CheckedKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetExpression = (Expression) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var uncheckedExpression = new GrammarDefinition("UncheckedExpression",
rule:
ToElement(UNCHECKED) + ToElement(OPEN_PARENS) + expression +
ToElement(CLOSE_PARENS),
createNode: node => new UncheckedExpression()
{
UncheckedKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
TargetExpression = (Expression) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
});
var stackAllocExpression = new GrammarDefinition("StackAllocExpression",
rule:
ToElement(STACKALLOC)
+ typeReference
+ ToElement(OPEN_BRACKET_EXPR)
+ expression
+ ToElement(CLOSE_BRACKET),
createNode: node => new StackAllocExpression()
{
StackAllocKeyword = (AstToken) node.Children[0].Result,
Type = (TypeReference) node.Children[1].Result,
LeftBracket = (AstToken) node.Children[2].Result,
Counter = (Expression) node.Children[3].Result,
RightBracket = (AstToken) node.Children[4].Result,
});
var explicitAnonymousMethodParameter = new GrammarDefinition("ExplicitAnonymousMethodParameter",
rule: typeReference + ToElement(IDENTIFIER),
createNode: node => new ParameterDeclaration
{
ParameterType = (TypeReference)node.Children[0].Result,
Declarator = new VariableDeclarator(ToIdentifier(node.Children[1].Result))
});
var explicitAnonymousMethodParameterList = new GrammarDefinition("ExplicitAnonymousMethodParameterList");
explicitAnonymousMethodParameterList.Rule = explicitAnonymousMethodParameter
| explicitAnonymousMethodParameterList
+ ToElement(COMMA)
+ explicitAnonymousMethodParameter;
var explicitAnonymousMethodParameterListOptional = new GrammarDefinition("ExplicitAnonymousMethodParameterListOptional",
rule: null | explicitAnonymousMethodParameterList);
var explicitAnonymousMethodSignature = new GrammarDefinition("ExplicitAnonymousMethodSignature",
rule: ToElement(OPEN_PARENS) + explicitAnonymousMethodParameterListOptional + ToElement(CLOSE_PARENS));
var explicitAnonymousMethodSignatureOptional =
new GrammarDefinition("ExplicitAnonymousMethodSignatureOptional",
rule: null | explicitAnonymousMethodSignature);
var anonymousMethodExpression = new GrammarDefinition("AnonymousMethodExpression",
rule: ToElement(DELEGATE) + explicitAnonymousMethodSignatureOptional + blockStatement,
createNode: node =>
{
var result = new AnonymousMethodExpression();
result.DelegateKeyword = (AstToken) node.Children[0].Result;
if (node.Children[1].HasChildren)
{
var signature = node.Children[1].Children[0];
result.LeftParenthese = (AstToken) signature.Children[0].Result;
if (signature.Children[1].HasChildren)
{
foreach (var child in signature.Children[1].Children[0].GetAllListAstNodes())
{
if (child is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, child);
else
result.Parameters.Add((ParameterDeclaration) child);
}
}
result.RightParenthese = (AstToken)signature.Children[2].Result;
}
result.Body = (BlockStatement) node.Children[2].Result;
return result;
});
var implicitAnonymousMethodParameter = new GrammarDefinition("ImplicitAnonymousMethodParameter",
rule: ToElement(IDENTIFIER),
createNode: node => new ParameterDeclaration
{
Declarator = new VariableDeclarator(ToIdentifier(node.Children[0].Result))
});
var implicitAnonymousMethodParameterList = new GrammarDefinition("ImplicitAnonymousMethodParameterList");
implicitAnonymousMethodParameterList.Rule = implicitAnonymousMethodParameter
| implicitAnonymousMethodParameterList
+ ToElement(COMMA)
+ implicitAnonymousMethodParameter;
var implicitAnonymousMethodParameterListOptional = new GrammarDefinition("ImplicitAnonymousMethodParameterListOptional",
rule: null | implicitAnonymousMethodParameterList);
var implicitAnonymousMethodSignature = new GrammarDefinition("implicitAnonymousMethodSignature",
rule: implicitAnonymousMethodParameter | ToElement(OPEN_PARENS_LAMBDA) + implicitAnonymousMethodParameterList + ToElement(CLOSE_PARENS));
var anonymousMethodSignature = new GrammarDefinition("AnonymousMethodSignature",
rule: implicitAnonymousMethodSignature);
var anonymousFunctionBody = new GrammarDefinition("AnonymousFunctionBody",
rule: expression | blockStatement);
var lambdaExpression = new GrammarDefinition("LambdaExpression",
rule: anonymousMethodSignature + ToElement(ARROW) + anonymousFunctionBody,
createNode: node =>
{
var result = new LambdaExpression();
result.Arrow = (AstToken)node.Children[1].Result;
result.Body = node.Children[2].Result;
return result;
});
primaryExpression.Rule =
typeNameExpression
| primitiveExpression
| parenthesizedExpression
| invocationExpression
| indexerExpression
| thisExpression
| baseExpression
| createObjectExpression
| createArrayExpression
| typeofExpression
| defaultExpression
| sizeofExpression
| checkedExpression
| uncheckedExpression
| stackAllocExpression
| anonymousMethodExpression
;
var preFixUnaryOperator = new GrammarDefinition("PreFixUnaryOperator",
rule: ToElement(PLUS)
| ToElement(MINUS)
| ToElement(STAR)
| ToElement(BANG)
| ToElement(OP_INC)
| ToElement(OP_DEC)
| ToElement(BITWISE_AND)
| ToElement(TILDE)
| ToElement(AWAIT));
var postFixUnaryOperator = new GrammarDefinition("PostFixUnaryOperator",
rule: ToElement(OP_INC)
| ToElement(OP_DEC));
var castExpression = new GrammarDefinition("CastExpression");
var unaryOperatorExpression = new GrammarDefinition("UnaryOperatorExpression",
rule: primaryExpression
| castExpression
| (preFixUnaryOperator + primaryExpression)
| (primaryExpression + postFixUnaryOperator),
createNode: node =>
{
if (node.Children.Count == 1)
return node.Children[0].Result;
var result = new UnaryOperatorExpression();
var isPrefix = node.Children[0].GrammarElement == preFixUnaryOperator;
if (isPrefix)
{
var operatorToken = ((AstToken) node.Children[0].Children[0].Result);
result.Operator = CSharpLanguage.UnaryOperatorFromString(operatorToken.Value);
result.OperatorToken = operatorToken;
}
result.Expression = (Expression) node.Children[isPrefix ? 1 : 0].Result;
if (!isPrefix)
{
var operatorToken = (AstToken) node.Children[1].Children[0].Result;
result.Operator = CSharpLanguage.UnaryOperatorFromString(operatorToken.Value, false);
result.OperatorToken = operatorToken;
}
return result;
});
castExpression.Rule = ToElement(OPEN_PARENS)
+ typeNameExpression
+ ToElement(CLOSE_PARENS)
+ unaryOperatorExpression;
castExpression.ComputeResult = node => new ExplicitCastExpression
{
LeftParenthese = (AstToken) node.Children[0].Result,
TargetType = ToTypeReference((IConvertibleToType) node.Children[1].Result),
RightParenthese = (AstToken) node.Children[2].Result,
TargetExpression = (Expression) node.Children[3].Result
};
var multiplicativeOperator = new GrammarDefinition("MultiplicativeOperator",
rule: ToElement(STAR)
| ToElement(DIV)
| ToElement(PERCENT));
var multiplicativeExpression = new GrammarDefinition("MultiplicativeExpression");
multiplicativeExpression.Rule = unaryOperatorExpression
| multiplicativeExpression
+ multiplicativeOperator
+ unaryOperatorExpression;
multiplicativeExpression.ComputeResult = createBinaryOperatorExpression;
var additiveOperator = new GrammarDefinition("AdditiveOperator",
rule: ToElement(PLUS)
| ToElement(MINUS));
var additiveExpression = new GrammarDefinition("AdditiveExpression");
additiveExpression.Rule = multiplicativeExpression
| additiveExpression
+ additiveOperator
+ multiplicativeExpression;
additiveExpression.ComputeResult = createBinaryOperatorExpression;
var shiftOperator = new GrammarDefinition("ShiftOperator",
rule: ToElement(OP_SHIFT_LEFT)
| ToElement(OP_SHIFT_RIGHT));
var shiftExpression = new GrammarDefinition("ShiftExpression");
shiftExpression.Rule = additiveExpression
| shiftExpression
+ shiftOperator
+ additiveExpression;
shiftExpression.ComputeResult = createBinaryOperatorExpression;
var relationalOperator = new GrammarDefinition("RelationalOperator",
rule: ToElement(OP_GT)
| ToElement(OP_GE)
| ToElement(OP_LT)
| ToElement(OP_LE)
| ToElement(IS)
| ToElement(AS));
var relationalExpression = new GrammarDefinition("RelationalExpression");
relationalExpression.Rule = shiftExpression
| relationalExpression
+ relationalOperator
+ shiftExpression;
relationalExpression.ComputeResult = node =>
{
if (node.Children.Count == 1)
return node.Children[0].Result;
var operatorToken = (CSharpAstToken) node.Children[1].Children[0].Result;
switch (operatorToken.Code)
{
case IS:
return new TypeCheckExpression()
{
TargetExpression = (Expression) node.Children[0].Result,
IsKeyword = operatorToken,
TargetType = ToTypeReference((IConvertibleToType) node.Children[2].Result)
};
case AS:
return new SafeCastExpression()
{
TargetExpression = (Expression) node.Children[0].Result,
CastKeyword = operatorToken,
TargetType = ToTypeReference((IConvertibleToType) node.Children[2].Result)
};
default:
return createBinaryOperatorExpression(node);
}
};
var equalityOperator = new GrammarDefinition("equalityOperator",
rule: ToElement(OP_EQUALS)
| ToElement(OP_NOTEQUALS));
var equalityExpression = new GrammarDefinition("EqualityExpression");
equalityExpression.Rule = relationalExpression
| equalityExpression
+ equalityOperator
+ relationalExpression;
equalityExpression.ComputeResult = createBinaryOperatorExpression;
var logicalAndExpression = new GrammarDefinition("LogicalAndExpression");
logicalAndExpression.Rule = equalityExpression
| logicalAndExpression
+ ToElement(BITWISE_AND)
+ equalityExpression;
logicalAndExpression.ComputeResult = createBinaryOperatorExpression;
var logicalXorExpression = new GrammarDefinition("LogicalOrExpression");
logicalXorExpression.Rule = logicalAndExpression
| logicalXorExpression
+ ToElement(CARRET)
+ logicalAndExpression;
logicalXorExpression.ComputeResult = createBinaryOperatorExpression;
var logicalOrExpression = new GrammarDefinition("LogicalOrExpression");
logicalOrExpression.Rule = logicalXorExpression
| logicalOrExpression
+ ToElement(BITWISE_OR)
+ logicalXorExpression;
logicalOrExpression.ComputeResult = createBinaryOperatorExpression;
var conditionalAndExpression = new GrammarDefinition("ConditionalAndExpression");
conditionalAndExpression.Rule = logicalOrExpression
| conditionalAndExpression
+ ToElement(OP_AND)
+ logicalOrExpression;
conditionalAndExpression.ComputeResult = createBinaryOperatorExpression;
var conditionalOrExpression = new GrammarDefinition("ConditionalOrExpression");
conditionalOrExpression.Rule = conditionalAndExpression
| conditionalOrExpression
+ ToElement(OP_OR)
+ conditionalAndExpression;
conditionalOrExpression.ComputeResult = createBinaryOperatorExpression;
var nullCoalescingExpression = new GrammarDefinition("NullCoalescingExpression");
nullCoalescingExpression.Rule = conditionalOrExpression
| nullCoalescingExpression
+ ToElement(OP_COALESCING)
+ conditionalOrExpression;
nullCoalescingExpression.ComputeResult = createBinaryOperatorExpression;
var conditionalExpression = new GrammarDefinition("ConditionalExpression",
rule: nullCoalescingExpression
| nullCoalescingExpression
+ ToElement(INTERR)
+ expression + ToElement(COLON) + expression,
createNode: node => node.Children.Count == 1
? node.Children[0].Result
: new ConditionalExpression
{
Condition = (Expression) node.Children[0].Result,
OperatorToken = (AstToken) node.Children[1].Result,
TrueExpression = (Expression) node.Children[2].Result,
ColonToken = (AstToken) node.Children[3].Result,
FalseExpression = (Expression) node.Children[4].Result
});
var assignmentOperator = new GrammarDefinition("AssignmentOperator",
rule: ToElement(EQUALS)
| ToElement(OP_ADD_ASSIGN)
| ToElement(OP_SUB_ASSIGN)
| ToElement(OP_MULT_ASSIGN)
| ToElement(OP_DIV_ASSIGN)
| ToElement(OP_AND_ASSIGN)
| ToElement(OP_OR_ASSIGN)
| ToElement(OP_XOR_ASSIGN)
| ToElement(OP_SHIFT_LEFT_ASSIGN)
| ToElement(OP_SHIFT_RIGHT_ASSIGN));
var assignmentExpression = new GrammarDefinition("AssignmentExpression",
rule: unaryOperatorExpression
+ assignmentOperator
+ expression,
createNode: node => new AssignmentExpression
{
Target = (Expression) node.Children[0].Result,
Operator = CSharpLanguage.AssignmentOperatorFromString(((AstToken) node.Children[1].Children[0].Result).Value),
OperatorToken = (AstToken) node.Children[1].Children[0].Result,
Value = (Expression) node.Children[2].Result,
});
var fromClause = new GrammarDefinition("FromClause",
rule: ToElement(FROM) + identifierInsideBody + ToElement(IN) + expression,
createNode: node => new LinqFromClause
{
FromKeyword = (AstToken) node.Children[0].Result,
VariableName = (Identifier) node.Children[1].Result,
InKeyword = (AstToken) node.Children[2].Result,
DataSource = (Expression) node.Children[3].Result
});
var letClause = new GrammarDefinition("LetClause",
rule: ToElement(LET) + variableDeclarator,
createNode: node => new LinqLetClause()
{
LetKeyword = (AstToken) node.Children[0].Result,
Variable = (VariableDeclarator) node.Children[1].Result
});
var whereClause = new GrammarDefinition("WhereClause",
rule: ToElement(WHERE) + expression,
createNode: node => new LinqWhereClause()
{
WhereKeyword = (AstToken) node.Children[0].Result,
Condition = (Expression) node.Children[1].Result
});
var orderingDirection = new GrammarDefinition("OrderingDirection",
rule: null | ToElement(ASCENDING) | ToElement(DESCENDING));
var ordering = new GrammarDefinition("Ordering",
rule: expression + orderingDirection,
createNode: node =>
{
var result = new LinqOrdering();
result.Expression = (Expression) node.Children[0].Result;
if (node.Children[1].HasChildren)
{
var directionNode = node.Children[1].Children[0];
result.DirectionKeyword = (AstToken) directionNode.Result;
result.Direction = directionNode.Result != null
? CSharpLanguage.OrderningDirectionFromString(result.DirectionKeyword.Value)
: LinqOrderingDirection.None;
}
return result;
});
var orderings = new GrammarDefinition("Orderings");
orderings.Rule = ordering | orderings + ToElement(COMMA) + ordering;
var orderByClause = new GrammarDefinition("OrderByClause",
rule: ToElement(ORDERBY) + orderings,
createNode: node =>
{
var result = new LinqOrderByClause();
result.OrderByKeyword = (AstToken) node.Children[0].Result;
foreach (var subNode in node.Children[1].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Ordernings.Add((LinqOrdering) subNode);
}
return result;
});
var groupByClause = new GrammarDefinition("GroupByClause",
rule: ToElement(GROUP) + expression + ToElement(BY) + expression,
createNode: node => new LinqGroupByClause()
{
GroupKeyword = (AstToken) node.Children[0].Result,
Expression = (Expression) node.Children[1].Result,
ByKeyword = (AstToken) node.Children[2].Result,
KeyExpression = (Expression) node.Children[3].Result
});
var selectClause = new GrammarDefinition("SelectClause",
rule: ToElement(SELECT) + expression,
createNode: node => new LinqSelectClause()
{
SelectKeyword = (AstToken) node.Children[0].Result,
Target = (Expression) node.Children[1].Result
});
var queryBodyClause = new GrammarDefinition("QueryBodyClause",
rule:
fromClause
| letClause
| groupByClause
| whereClause
| orderByClause
);
var queryBodyClauses = new GrammarDefinition("QueryBodyClauses");
queryBodyClauses.Rule = queryBodyClause | queryBodyClauses + queryBodyClause;
var queryBodyClausesOptional = new GrammarDefinition("QueryBodyClausesOptional",
rule: null | queryBodyClauses);
var linqExpression = new GrammarDefinition("LinqExpression",
rule: fromClause + queryBodyClausesOptional + selectClause,
createNode: node =>
{
var result = new LinqExpression();
result.Clauses.Add((LinqClause) node.Children[0].Result);
if (node.Children[1].HasChildren)
{
result.Clauses.AddRange(node.Children[1].Children[0].GetAllListAstNodes().Cast<LinqClause>());
}
result.Clauses.Add((LinqClause) node.Children[2].Result);
return result;
});
expression.Rule = conditionalExpression
| linqExpression
| lambdaExpression
| assignmentExpression;
#endregion
#region Statements
var statement = new GrammarDefinition("Statement");
var embeddedStatement = new GrammarDefinition("EmbeddedStatement");
var emptyStatement = new GrammarDefinition("EmptyStatement",
rule: ToElement(SEMICOLON),
createNode: node =>
{
var result = new EmptyStatement();
result.AddChild(AstNodeTitles.Semicolon, node.Children[0].Result);
return result;
});
var labelStatement = new GrammarDefinition("LabelStatement",
rule: identifierInsideBody + ToElement(COLON),
createNode: node => new LabelStatement((Identifier) node.Children[0].Result)
{
Colon = (AstToken) node.Children[1].Result
});
var expressionStatement = new GrammarDefinition("ExpressionStatement",
rule: expression + ToElement(SEMICOLON)
| Error + ToElement(SEMICOLON)
| Error + ToElement(CLOSE_BRACE)
| expression + ToElement(CLOSE_BRACE), // Common mistake in C# is to forget the semicolon at the end of a statement.
createNode: node =>
{
var result = new ExpressionStatement(node.Children[0].Result as Expression);
var endingToken = (AstToken) node.Children[1].Result;
if (endingToken.GetTokenCode() == (int) SEMICOLON)
{
result.AddChild(AstNodeTitles.Semicolon, node.Children[1].Result);
}
else
{
node.Context.SyntaxErrors.Add(new SyntaxError(
node.Children[1].Range.End,
"';' expected.",
MessageSeverity.Error));
node.Context.Lexer.PutBack((AstToken) endingToken);
}
return result;
});
blockStatement.Rule = ToElement(OPEN_BRACE)
+ statementListOptional
+ ToElement(CLOSE_BRACE);
blockStatement.ComputeResult = node =>
{
var result = new BlockStatement();
result.StartScope = node.Children[0].Result;
if (node.Children[1].HasChildren)
{
result.Statements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<Statement>());
}
result.EndScope = node.Children[2].Result;
return result;
};
var variableDeclarationStatement = new GrammarDefinition("VariableDeclarationStatement",
rule: variableDeclaration
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = node.Children[0].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[1].Result);
return result;
});
var ifElseStatement = new GrammarDefinition("IfElseStatement",
rule: ToElement(IF) + parenthesizedExpression + embeddedStatement
| ToElement(IF) + parenthesizedExpression + embeddedStatement + ToElement(ELSE) + embeddedStatement
,
createNode: node =>
{
var result = new IfElseStatement();
result.IfKeyword = (AstToken) node.Children[0].Result;
var parenthesized = (ParenthesizedExpression) node.Children[1].Result;
result.LeftParenthese = (AstToken) parenthesized.LeftParenthese.Remove();
result.Condition = (Expression) parenthesized.Expression?.Remove();
result.RightParenthese = (AstToken) parenthesized.RightParenthese.Remove();
result.TrueBlock = (Statement) node.Children[2].Result;
if (node.Children.Count > 3)
{
result.ElseKeyword = (AstToken) node.Children[3].Result;
result.FalseBlock = (Statement) node.Children[4].Result;
CheckForPossibleMistakenEmptyStatement(node.Children[4]);
}
else
{
CheckForPossibleMistakenEmptyStatement(node.Children[2]);
}
return result;
});
var switchLabel = new GrammarDefinition("SwitchLabel",
rule: ToElement(CASE) + expression + ToElement(COLON)
| ToElement(DEFAULT_COLON) + ToElement(COLON),
createNode: node =>
{
var result = new SwitchCaseLabel();
result.CaseKeyword = (AstToken) node.Children[0].Result;
if (node.Children.Count > 2)
result.Condition = (Expression) node.Children[1].Result;
result.Colon = (AstToken) node.Children[node.Children.Count - 1].Result;
return result;
});
var switchLabels = new GrammarDefinition("SwitchLabels");
switchLabels.Rule = switchLabel | switchLabels + switchLabel;
var switchSection = new GrammarDefinition("SwitchSection",
rule: switchLabels + statementList,
createNode: node =>
{
var result = new SwitchSection();
result.Labels.AddRange(node.Children[0].GetAllListAstNodes<SwitchCaseLabel>());
result.Statements.AddRange(node.Children[1].GetAllListAstNodes<Statement>());
return result;
});
var switchSections = new GrammarDefinition("SwitchSections");
switchSections.Rule = switchSection
| switchSections + switchSection;
var switchBlock = new GrammarDefinition("SwitchBlock",
rule: ToElement(OPEN_BRACE)
+ switchSections
+ ToElement(CLOSE_BRACE));
var switchStatement = new GrammarDefinition("SwitchStatement",
rule: ToElement(SWITCH)
+ ToElement(OPEN_PARENS)
+ expression
+ ToElement(CLOSE_PARENS)
+ switchBlock,
createNode: node =>
{
var result = new SwitchStatement();
result.SwitchKeyword = (AstToken) node.Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
result.Condition = (Expression) node.Children[2].Result;
result.RightParenthese = (AstToken) node.Children[3].Result;
var switchBlockNode = node.Children[4];
result.StartScope = switchBlockNode.Children[0].Result;
result.Sections.AddRange(switchBlockNode.Children[1].GetAllListAstNodes<SwitchSection>());
result.EndScope = switchBlockNode.Children[2].Result;
return result;
});
var selectionStatement = new GrammarDefinition("SelectionStatement",
rule: ifElseStatement
| switchStatement);
var whileLoopStatement = new GrammarDefinition("WhileLoopStatement",
rule: ToElement(WHILE)
+ parenthesizedExpression
+ embeddedStatement,
createNode: node =>
{
var bodyNode = node.Children[2];
CheckForPossibleMistakenEmptyStatement(bodyNode);
var conditionExpr = (ParenthesizedExpression) node.Children[1].Result;
return new WhileLoopStatement
{
WhileKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) conditionExpr.LeftParenthese.Remove(),
Condition = (Expression) conditionExpr.Expression.Remove(),
RightParenthese = (AstToken) conditionExpr.RightParenthese.Remove(),
Body = (Statement) bodyNode.Result
};
});
var doLoopStatement = new GrammarDefinition("DoLoopStatement",
rule: ToElement(DO)
+ embeddedStatement
+ ToElement(WHILE)
+ parenthesizedExpression
+ ToElement(SEMICOLON),
createNode: node =>
{
var conditionExpr = (ParenthesizedExpression) node.Children[3].Result;
return new DoLoopStatement
{
DoKeyword = (AstToken) node.Children[0].Result,
Body = (Statement) node.Children[1].Result,
WhileKeyword = (AstToken) node.Children[2].Result,
LeftParenthese = (AstToken) conditionExpr.LeftParenthese.Remove(),
Condition = (Expression) conditionExpr.Expression.Remove(),
RightParenthese = (AstToken) conditionExpr.RightParenthese.Remove(),
Semicolon = (AstToken) node.Children[4].Result
};
});
var forLoopInitializer = new GrammarDefinition("ForLoopInitializer",
rule: variableDeclaration
| null
// TODO: statement-expression-list
);
var forLoopCondition = new GrammarDefinition("ForLoopCondition",
rule: expression
| null);
var forLoopStatement = new GrammarDefinition("ForLoopStatement",
rule: ToElement(FOR)
+ ToElement(OPEN_PARENS)
+ forLoopInitializer
+ ToElement(SEMICOLON)
+ expressionOptional
+ ToElement(SEMICOLON)
+ expressionOptional // TODO: statement-expression-list
+ ToElement(CLOSE_PARENS)
+ embeddedStatement,
createNode: node =>
{
var result = new ForLoopStatement();
result.ForKeyword = (AstToken) node.Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
if (node.Children[2].HasChildren)
{
var declaration = node.Children[2].Children[0].Result as VariableDeclarationStatement;
if (declaration != null)
{
result.Initializers.Add(declaration);
}
else
{
result.Initializers.AddRange(node.Children[2].GetAllListAstNodes<Expression>()
.Select(x => new ExpressionStatement(x)));
}
}
result.AddChild(AstNodeTitles.Semicolon, node.Children[3].Result);
if (node.Children[4].HasChildren)
result.Condition = (Expression) node.Children[4].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[5].Result);
if (node.Children[6].HasChildren)
{
result.Iterators.AddRange(node.Children[6].Children[0].GetAllListAstNodes<Expression>()
.Select(x => new ExpressionStatement(x)));
}
result.RightParenthese = (AstToken) node.Children[7].Result;
var bodyNode = node.Children[8];
CheckForPossibleMistakenEmptyStatement(bodyNode);
result.Body = (Statement) bodyNode.Result;
return result;
});
var foreachLoopStatement = new GrammarDefinition("ForEachLoopStatement",
rule: ToElement(FOREACH)
+ ToElement(OPEN_PARENS)
+ typeReference
+ identifierInsideBody
+ ToElement(IN)
+ expression
+ ToElement(CLOSE_PARENS)
+ embeddedStatement,
createNode: node =>
{
var bodyNode = node.Children[7];
CheckForPossibleMistakenEmptyStatement(bodyNode);
return new ForeachLoopStatement
{
ForeachKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
Type = (TypeReference) node.Children[2].Result,
Identifier = (Identifier) node.Children[3].Result,
InKeyword = (AstToken) node.Children[4].Result,
Target = (Expression) node.Children[5].Result,
RightParenthese = (AstToken) node.Children[6].Result,
Body = (Statement) bodyNode.Result
};
});
var loopStatement = new GrammarDefinition("LoopStatement",
rule: whileLoopStatement
| doLoopStatement
| forLoopStatement
| foreachLoopStatement);
var lockStatement = new GrammarDefinition("LockStatement",
rule: ToElement(LOCK)
+ ToElement(OPEN_PARENS)
+ expression
+ ToElement(CLOSE_PARENS)
+ statement,
createNode: node =>
{
var bodyNode = node.Children[4];
CheckForPossibleMistakenEmptyStatement(bodyNode);
return new LockStatement
{
LockKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
LockObject = (Expression) node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
Body = (Statement) bodyNode.Result
};
});
var resourceAcquisition = new GrammarDefinition("ResourceAcquisition",
rule: variableDeclaration | expression);
var usingStatement = new GrammarDefinition("UsingStatement",
rule: ToElement(USING)
+ ToElement(OPEN_PARENS)
+ resourceAcquisition
+ ToElement(CLOSE_PARENS)
+ statement,
createNode: node =>
{
var bodyNode = node.Children[4];
CheckForPossibleMistakenEmptyStatement(bodyNode);
return new UsingStatement()
{
UsingKeyword = (AstToken) node.Children[0].Result,
LeftParenthese = (AstToken) node.Children[1].Result,
DisposableObject = node.Children[2].Result,
RightParenthese = (AstToken) node.Children[3].Result,
Body = (Statement) bodyNode.Result
};
});
var breakStatement = new GrammarDefinition("BreakStatement",
rule: ToElement(BREAK)
+ ToElement(SEMICOLON),
createNode: node => new BreakStatement()
{
Keyword = (AstToken) node.Children[0].Result,
Semicolon = (AstToken) node.Children[1].Result
});
var continueStatement = new GrammarDefinition("ContinueStatement",
rule: ToElement(CONTINUE)
+ ToElement(SEMICOLON),
createNode: node => new BreakStatement()
{
Keyword = (AstToken) node.Children[0].Result,
Semicolon = (AstToken) node.Children[1].Result
});
var returnStatement = new GrammarDefinition("ReturnStatement",
rule: ToElement(RETURN)
+ expressionOptional
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new ReturnStatement();
result.ReturnKeyword = (AstToken) node.Children[0].Result;
if (node.Children[1].HasChildren)
result.Value = (Expression) node.Children[1].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[2].Result);
return result;
});
var throwStatement = new GrammarDefinition("ThrowStatement",
rule: ToElement(THROW)
+ expressionOptional
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new ThrowStatement();
result.ThrowKeyword = (AstToken) node.Children[0].Result;
if (node.Children[1].HasChildren)
result.Expression = (Expression) node.Children[1].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[2].Result);
return result;
});
var gotoStatement = new GrammarDefinition("GotoStatement",
rule: ToElement(GOTO)
+ identifierInsideBody
+ ToElement(SEMICOLON),
// TODO: goto case and goto default statements.
createNode: node =>
{
var result = new GotoStatement();
result.GotoKeyword = (AstToken) node.Children[0].Result;
result.LabelIdentifier = (Identifier) node.Children[1].Result;
result.AddChild(AstNodeTitles.Semicolon, node.Children[2].Result);
return result;
});
var jumpStatement = new GrammarDefinition("JumpStatement",
rule: breakStatement
| continueStatement
| gotoStatement
| returnStatement
| throwStatement);
var yieldStatement = new GrammarDefinition("YieldStatement",
rule: ToElement(YIELD)
+ ToElement(RETURN)
+ expression
+ ToElement(SEMICOLON),
createNode: node => new YieldStatement()
{
YieldKeyword = (AstToken) node.Children[0].Result,
ReturnKeyword = (AstToken) node.Children[1].Result,
Value = (Expression) node.Children[2].Result
});
var yieldBreakStatement = new GrammarDefinition("YieldBreakStatement",
rule: ToElement(YIELD)
+ ToElement(BREAK)
+ ToElement(SEMICOLON),
createNode: node => new YieldBreakStatement()
{
Keyword = (AstToken) node.Children[0].Result,
BreakKeyword = (AstToken) node.Children[1].Result
});
var specificCatchClause = new GrammarDefinition("SpecificCatchClause",
rule: ToElement(CATCH) + ToElement(OPEN_PARENS)
+ namespaceOrTypeExpression + identifierInsideBodyOptional + ToElement(CLOSE_PARENS)
+ blockStatement,
createNode: node =>
{
var result = new CatchClause();
result.CatchKeyword = (AstToken) node.Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
result.ExceptionType = (TypeReference) node.Children[2].Result;
if (node.Children[3].HasChildren)
result.ExceptionIdentifier = (Identifier) node.Children[3].Result;
result.RightParenthese = (AstToken) node.Children[4].Result;
result.Body = (BlockStatement) node.Children[5].Result;
return result;
});
var generalCatchClause = new GrammarDefinition("GeneralCatchClause",
rule: ToElement(CATCH) + blockStatement,
createNode: node => new CatchClause
{
CatchKeyword = (AstToken) node.Children[0].Result,
Body = (BlockStatement) node.Children[1].Result
});
var catchClause = new GrammarDefinition("CatchClause",
rule: specificCatchClause | generalCatchClause);
var catchClauses = new GrammarDefinition("CatchClauses");
catchClauses.Rule = catchClause | catchClauses + catchClause;
var finallyClause = new GrammarDefinition("FinallyClause",
rule: ToElement(FINALLY) + blockStatement);
var tryCatchStatement = new GrammarDefinition("TryCatchStatement",
rule: ToElement(TRY) + blockStatement + catchClauses
| ToElement(TRY) + blockStatement + finallyClause
| ToElement(TRY) + blockStatement + catchClauses + finallyClause,
createNode: node =>
{
var result = new TryCatchStatement();
result.TryKeyword = (AstToken) node.Children[0].Result;
result.TryBlock = (BlockStatement) node.Children[1].Result;
ParserNode finallyClauseNode = null;
if (node.Children[2].GrammarElement == finallyClause)
{
finallyClauseNode = node.Children[2];
}
else
{
result.CatchClauses.AddRange(node.Children[2].GetAllListAstNodes<CatchClause>());
}
if (node.Children.Count == 4)
finallyClauseNode = node.Children[3];
if (finallyClauseNode != null)
{
result.FinallyKeyword = (AstToken) finallyClauseNode.Children[0].Result;
result.FinallyBlock = (BlockStatement) finallyClauseNode.Children[1].Result;
}
return result;
});
var unsafeStatement = new GrammarDefinition("UnsafeStatement",
rule: ToElement(UNSAFE) + blockStatement,
createNode: node => new UnsafeStatement()
{
Keyword = (AstToken) node.Children[0].Result,
Body = (BlockStatement) node.Children[1].Result
});
var fixedStatement = new GrammarDefinition("FixedStatement",
rule: ToElement(FIXED) + ToElement(OPEN_PARENS)
+ variableDeclaration + ToElement(CLOSE_PARENS) + embeddedStatement,
createNode: node =>
{
var result = new FixedStatement();
result.Keyword = (AstToken) node.Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
result.VariableDeclaration = (VariableDeclarationStatement) node.Children[2].Result;
result.RightParenthese = (AstToken) node.Children[3].Result;
var bodyNode = node.Children[4];
result.Body = (Statement) bodyNode.Result;
CheckForPossibleMistakenEmptyStatement(bodyNode);
return result;
});
embeddedStatement.Rule = emptyStatement
| expressionStatement
| blockStatement
| selectionStatement
| loopStatement
| jumpStatement
| lockStatement
| usingStatement
| yieldStatement
| yieldBreakStatement
| tryCatchStatement
| unsafeStatement
| fixedStatement
;
statement.Rule = variableDeclarationStatement
| labelStatement
| embeddedStatement;
;
#endregion
#region Members
var customAttribute = new GrammarDefinition("CustomAttribute",
rule: namespaceOrTypeExpression
| namespaceOrTypeExpression + ToElement(OPEN_PARENS) + argumentListOptional + ToElement(CLOSE_PARENS),
createNode: node =>
{
var result = new CustomAttribute();
result.Type = ((IConvertibleToType) node.Children[0].Result).ToTypeReference();
if (node.Children.Count > 1)
{
result.LeftParenthese = (AstToken) node.Children[1].Result;
if (node.Children[2].HasChildren)
{
foreach (var child in node.Children[2].Children[0].GetAllListAstNodes())
{
if (child is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, child);
else
result.Arguments.Add((Expression) child);
}
}
result.RightParenthese = (AstToken) node.Children[3].Result;
}
return result;
});
var customAttributeList = new GrammarDefinition("CustomAttributeList");
customAttributeList.Rule = customAttribute | customAttributeList + ToElement(COMMA) + customAttribute;
var customAttributePrefix = new GrammarDefinition("CustomAttributePrefix",
rule: ToElement(ASSEMBLY) | ToElement(MODULE));
var customAttributePrefixOptional = new GrammarDefinition("CustomAttributePrefixOptional",
rule: null | customAttributePrefix + ToElement(COLON));
var customAttributeSection = new GrammarDefinition("CustomAttributeSection",
rule: ToElement(OPEN_BRACKET_EXPR) // HACK: use expression brackets instead to avoid conflicts.
+ customAttributePrefixOptional
+ customAttributeList
+ ToElement(CLOSE_BRACKET),
createNode: node =>
{
var result = new CustomAttributeSection();
result.LeftBracket = (AstToken) node.Children[0].Result;
if (node.Children[1].Result != null)
{
result.VariantKeyword = (AstToken) node.Children[1].Result;
result.Variant = CSharpLanguage.SectionVariantFromString(result.VariantKeyword.Value);
}
foreach (var child in node.Children[2].GetAllListAstNodes())
{
if (child is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, child);
else
result.Attributes.Add((CustomAttribute) child);
}
result.RightBracket = (AstToken) node.Children[3].Result;
return result;
});
var customAttributeSectionList = new GrammarDefinition("CustomAttributeSectionList");
customAttributeSectionList.Rule = customAttributeSection | customAttributeSectionList + customAttributeSection;
var customAttributeSectionListOptional = new GrammarDefinition("CustomAttributeSectionListOptional",
rule: null | customAttributeSectionList);
var modifier = new GrammarDefinition("Modifier",
rule: ToElement(PRIVATE)
| ToElement(PROTECTED)
| ToElement(INTERNAL)
| ToElement(PUBLIC)
| ToElement(STATIC)
| ToElement(ABSTRACT)
| ToElement(OVERRIDE)
| ToElement(PARTIAL)
| ToElement(CONST)
| ToElement(READONLY)
| ToElement(VIRTUAL)
| ToElement(SEALED)
| ToElement(UNSAFE)
| ToElement(FIXED)
| ToElement(ASYNC)
| ToElement(EXTERN),
createNode: node => new ModifierElement(((AstToken) node.Children[0].Result).Value, node.Children[0].Range)
{
Modifier = CSharpLanguage.ModifierFromString(((AstToken) node.Children[0].Result).Value)
});
var modifierList = new GrammarDefinition("ModifierList");
modifierList.Rule = modifier | modifierList + modifier;
var modifierListOptional = new GrammarDefinition("ModifierListOptional",
rule: null | modifierList);
var fieldDeclaration = new GrammarDefinition("FieldDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeReference
+ variableDeclaratorList
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new FieldDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.FieldType = (TypeReference) node.Children[2].Result;
foreach (var subNode in node.Children[3].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Declarators.Add((VariableDeclarator) subNode);
}
result.AddChild(AstNodeTitles.Semicolon, node.Children[4].Result);
return result;
});
var parameterModifier = new GrammarDefinition("ParameterModifier",
rule: null
| ToElement(THIS)
| ToElement(REF)
| ToElement(OUT)
| ToElement(PARAMS));
var parameterDeclaration = new GrammarDefinition("ParameterDeclaration",
rule: customAttributeSectionListOptional
+ parameterModifier
+ typeReference
+ variableDeclarator,
createNode: node =>
{
var result = new ParameterDeclaration();
if (node.Children[0].HasChildren)
{
result.CustomAttributeSections.AddRange(
node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
}
result.ParameterModifierToken = (AstToken) (node.Children[1].HasChildren ? node.Children[1].Children[0].Result : null);
result.ParameterType = (TypeReference) node.Children[2].Result;
result.Declarator = (VariableDeclarator) node.Children[3].Result;
return result;
});
var parameterDeclarationList = new GrammarDefinition("ParameterDeclarationList");
parameterDeclarationList.Rule = parameterDeclaration | parameterDeclarationList + ToElement(COMMA) + parameterDeclaration;
var optionalParameterDeclarationList = new GrammarDefinition("OptionalParameterDeclarationList",
rule: null | parameterDeclarationList);
var constructorInitializerVariant = new GrammarDefinition("ConstructorInitializerVariant",
rule: ToElement(THIS) | ToElement(BASE));
var constructorInitializer = new GrammarDefinition("ConstructorInitializer",
rule: constructorInitializerVariant
+ ToElement(OPEN_PARENS)
+ argumentListOptional
+ ToElement(CLOSE_PARENS),
createNode: node =>
{
var result = new Members.ConstructorInitializer();
result.VariantToken = (AstToken) node.Children[0].Children[0].Result;
result.LeftParenthese = (AstToken) node.Children[1].Result;
if (node.Children[2].HasChildren)
{
foreach (var subNode in node.Children[2].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Arguments.Add((Expression) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[3].Result;
return result;
});
var optionalConstructorInitializerList = new GrammarDefinition("OptionalConstructorInitializer",
rule: null | ToElement(COLON) + constructorInitializer);
var constructorDeclaration = new GrammarDefinition("ConstructorDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ ToElement(IDENTIFIER)
+ ToElement(OPEN_PARENS)
+ optionalParameterDeclarationList
+ ToElement(CLOSE_PARENS)
+ optionalConstructorInitializerList
+ blockStatement,
createNode: node =>
{
var result = new Members.ConstructorDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.Identifier = ToIdentifier(node.Children[2].Result);
result.LeftParenthese = (AstToken) node.Children[3].Result;
if (node.Children[4].HasChildren)
{
foreach (var subNode in node.Children[4].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Parameters.Add((ParameterDeclaration) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[5].Result;
if (node.Children[6].HasChildren)
{
result.Colon = (AstToken) node.Children[6].Children[0].Result;
result.Initializer = (Members.ConstructorInitializer) node.Children[6].Children[1].Result;
}
result.Body = (BlockStatement) node.Children[7].Result;
return result;
});
var conversionOperator = new GrammarDefinition("ConversionOperator",
rule: ToElement(IMPLICIT)
| ToElement(EXPLICIT));
var conversionOperatorDeclaration = new GrammarDefinition("ConversionOperatorDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ conversionOperator
+ ToElement(OPERATOR)
+ ToElement(IDENTIFIER)
+ ToElement(OPEN_PARENS)
+ optionalParameterDeclarationList
+ ToElement(CLOSE_PARENS)
+ blockStatement,
createNode: node =>
{
var result = new OperatorDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.Identifier = ToIdentifier(node.Children[2].Result);
result.OperatorType = CSharpLanguage.OperatorDeclarationTypeFromString(result.Identifier.Name);
result.OperatorKeyword = (AstToken) node.Children[3].Result;
result.ReturnType = ToTypeReference(ToIdentifier(node.Children[4].Result));
result.LeftParenthese = (AstToken)node.Children[5].Result;
if (node.Children[6].HasChildren)
{
foreach (var subNode in node.Children[6].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Parameters.Add((ParameterDeclaration)subNode);
}
}
result.RightParenthese = (AstToken) node.Children[7].Result;
result.Body = (BlockStatement) node.Children[8].Result;
return result;
});
var overloadableOperator = new GrammarDefinition("OverloadableOperator",
rule: ToElement(PLUS)
| ToElement(MINUS)
| ToElement(STAR)
| ToElement(DIV)
| ToElement(PERCENT)
| ToElement(BITWISE_AND)
| ToElement(BITWISE_OR)
| ToElement(CARRET)
| ToElement(OP_EQUALS)
| ToElement(OP_NOTEQUALS)
| ToElement(OP_GT)
| ToElement(OP_GE)
| ToElement(OP_LT)
| ToElement(OP_LE)
| ToElement(OP_SHIFT_LEFT)
| ToElement(OP_SHIFT_RIGHT)
| ToElement(TRUE)
| ToElement(FALSE)
| ToElement(BANG)
| ToElement(TILDE)
| ToElement(OP_INC)
| ToElement(OP_DEC));
var arithmeticOperatorDeclaration = new GrammarDefinition("ArithmeticOperatorDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeReference
+ ToElement(OPERATOR)
+ overloadableOperator
+ ToElement(OPEN_PARENS)
+ optionalParameterDeclarationList
+ ToElement(CLOSE_PARENS)
+ blockStatement,
createNode: node =>
{
var result = new OperatorDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.ReturnType = (TypeReference) node.Children[2].Result;
result.OperatorKeyword = (AstToken)node.Children[3].Result;
result.Identifier = ToIdentifier(node.Children[4].Result);
result.LeftParenthese = (AstToken)node.Children[5].Result;
if (node.Children[6].HasChildren)
{
foreach (var subNode in node.Children[6].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Parameters.Add((ParameterDeclaration)subNode);
}
}
result.RightParenthese = (AstToken)node.Children[7].Result;
result.OperatorType = CSharpLanguage.OperatorDeclarationTypeFromString(result.Identifier.Name);
if (result.Parameters.Count == 2)
{
if (result.OperatorType == OperatorDeclarationType.Positive)
result.OperatorType = OperatorDeclarationType.Add;
else if (result.OperatorType == OperatorDeclarationType.Negative)
result.OperatorType = OperatorDeclarationType.Subtract;
}
result.Body = (BlockStatement)node.Children[8].Result;
return result;
});
var operatorDeclaration = new GrammarDefinition("OperatorDeclaration",
rule: conversionOperatorDeclaration | arithmeticOperatorDeclaration);
var methodDeclarationBody = new GrammarDefinition("MethodDeclarationBody",
rule: ToElement(SEMICOLON) | blockStatement);
var methodDeclaration = new GrammarDefinition("MethodDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeReference
+ ToElement(IDENTIFIER)
+ ToElement(OPEN_PARENS)
+ optionalParameterDeclarationList
+ ToElement(CLOSE_PARENS)
+ methodDeclarationBody,
createNode: node =>
{
var result = new MethodDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.ReturnType = (TypeReference) node.Children[2].Result;
result.Identifier = ToIdentifier(node.Children[3].Result);
result.LeftParenthese = (AstToken) node.Children[4].Result;
if (node.Children[5].HasChildren)
{
foreach (var subNode in node.Children[5].Children[0].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Parameters.Add((ParameterDeclaration) subNode);
}
}
result.RightParenthese = (AstToken) node.Children[6].Result;
var body = node.Children[7].Result;
if (body is AstToken)
result.AddChild(AstNodeTitles.Semicolon, (AstToken) body);
else
result.Body = (BlockStatement) body;
return result;
});
var eventDeclaration = new GrammarDefinition("EventDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ ToElement(EVENT)
+ typeReference
+ variableDeclaratorList
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new EventDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.EventKeyword = (AstToken) node.Children[2].Result;
result.EventType = (TypeReference) node.Children[3].Result;
foreach (var subNode in node.Children[4].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Declarators.Add((VariableDeclarator) subNode);
}
result.AddChild(AstNodeTitles.Semicolon, node.Children[5].Result);
return result;
});
var accessorKeyword = new GrammarDefinition("AccessorKeyword",
rule: ToElement(GET)
| ToElement(SET));
var accessorBody = new GrammarDefinition("AccessorBody",
rule: ToElement(SEMICOLON)
| blockStatement);
var accessorDeclaration = new GrammarDefinition("AccessorDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ accessorKeyword
+ accessorBody,
createNode: node =>
{
var result = new AccessorDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.AccessorKeyword = (AstToken) node.Children[2].Children[0].Result;
var bodyNode = node.Children[3].Children[0].Result;
if (bodyNode is AstToken)
result.AddChild(AstNodeTitles.Semicolon, bodyNode);
else
result.Body = (BlockStatement) bodyNode;
return result;
});
var accessorDeclarationList = new GrammarDefinition("AccessorDeclarationList");
accessorDeclarationList.Rule = accessorDeclaration | accessorDeclaration + accessorDeclaration;
var propertyDeclaration = new GrammarDefinition("PropertyDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeReference
+ ToElement(IDENTIFIER)
+ ToElement(OPEN_BRACE)
+ accessorDeclarationList
+ ToElement(CLOSE_BRACE),
createNode: node =>
{
var result = new PropertyDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
result.PropertyType = (TypeReference) node.Children[2].Result;
result.Identifier = ToIdentifier(node.Children[3].Result);
result.StartScope = node.Children[4].Result;
foreach (var accessor in node.Children[5].Children)
{
var declaration = (AccessorDeclaration) accessor.Result;
// TODO: detect duplicate accessor declarations.
switch (declaration.AccessorKeyword.Value)
{
case "get":
result.Getter = declaration;
break;
case "set":
result.Setter = declaration;
break;
}
}
result.EndScope = node.Children[6].Result;
return result;
});
var memberDeclaration = new GrammarDefinition("MemberDeclaration");
var memberDeclarationList = new GrammarDefinition("MemberDeclarationList");
memberDeclarationList.Rule = memberDeclaration | memberDeclarationList + memberDeclaration;
var memberDeclarationListOptional = new GrammarDefinition("MemberDeclarationListOptional");
memberDeclarationListOptional.Rule = null | memberDeclarationList;
var baseTypeList = new GrammarDefinition("BaseTypeList");
baseTypeList.Rule = typeReference | baseTypeList + ToElement(COMMA) + typeReference;
var optionalBaseTypeList = new GrammarDefinition("OptionalBaseTypeList");
optionalBaseTypeList.Rule = null | ToElement(COLON) + baseTypeList;
var typeVariantKeyword = new GrammarDefinition("TypeVariantKeyword",
rule: ToElement(CLASS)
| ToElement(STRUCT)
| ToElement(INTERFACE)
| ToElement(ENUM));
var typeDeclaration = new GrammarDefinition("TypeDeclaration",
rule: customAttributeSectionListOptional
+ modifierListOptional
+ typeVariantKeyword
+ ToElement(IDENTIFIER)
+ optionalBaseTypeList
+ ToElement(OPEN_BRACE)
+ memberDeclarationListOptional
+ ToElement(CLOSE_BRACE),
createNode: node =>
{
var result = new TypeDeclaration();
if (node.Children[0].HasChildren)
result.CustomAttributeSections.AddRange(node.Children[0].Children[0].GetAllListAstNodes<CustomAttributeSection>());
if (node.Children[1].HasChildren)
result.ModifierElements.AddRange(node.Children[1].Children[0].GetAllListAstNodes<ModifierElement>());
var variantToken = (AstToken) node.Children[2].Children[0].Result;
result.TypeVariant = CSharpLanguage.TypeVariantFromString(variantToken.Value);
result.TypeVariantToken = variantToken;
result.Identifier = ToIdentifier(node.Children[3].Result);
if (node.Children[4].HasChildren)
{
result.AddChild(AstNodeTitles.Colon, node.Children[4].Children[0].Result);
foreach (var child in node.Children[4].Children[1].GetAllListAstNodes())
{
if (child is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, child);
else
result.BaseTypes.Add((TypeReference) child);
}
}
result.StartScope = node.Children[5].Result;
if (node.Children[6].HasChildren)
{
result.Members.AddRange(node.Children[6].Children[0].GetAllListAstNodes<MemberDeclaration>());
}
result.EndScope = node.Children[7].Result;
return result;
});
memberDeclaration.Rule = methodDeclaration
| constructorDeclaration
| operatorDeclaration
| propertyDeclaration
| eventDeclaration
| fieldDeclaration
| typeDeclaration
;
var typeOrNamespaceDeclarationList = new GrammarDefinition("TypeOrNamespaceDeclarationList");
var typeOrNamespaceDeclarationListOptional = new GrammarDefinition("TypeOrNamespaceDeclarationListOptional",
rule: null | typeOrNamespaceDeclarationList);
var namespaceDeclaration = new GrammarDefinition("NamespaceDeclaration",
rule: ToElement(NAMESPACE)
+ typeNameExpression
+ ToElement(OPEN_BRACE)
+ usingDirectiveListOptional
+ typeOrNamespaceDeclarationListOptional
+ ToElement(CLOSE_BRACE),
createNode: node =>
{
var result = new NamespaceDeclaration();
result.Keyword = (AstToken) node.Children[0].Result;
result.Identifier = ((IConvertibleToIdentifier) node.Children[1].Result).ToIdentifier();
result.StartScope = node.Children[2].Result;
if (node.Children[3].HasChildren)
{
result.UsingDirectives.AddRange(node.Children[3].Children[0].GetAllListAstNodes<UsingDirective>());
}
if (node.Children[4].HasChildren)
{
foreach (var subNode in node.Children[4].Children[0].GetAllListAstNodes())
{
var type = subNode as TypeDeclaration;
if (type != null)
result.Types.Add(type);
else
result.Namespaces.Add((NamespaceDeclaration) subNode);
}
}
result.EndScope = node.Children[5].Result;
return result;
});
var typeOrNamespaceDeclaration = new GrammarDefinition("TypeOrNamespaceDeclaration",
rule: namespaceDeclaration
| typeDeclaration);
typeOrNamespaceDeclarationList.Rule = typeOrNamespaceDeclaration
| typeOrNamespaceDeclarationList
+ typeOrNamespaceDeclaration;
#endregion
#region Initialize definitions
var variableInitializerList = new GrammarDefinition("VariableInitializerList");
variableInitializerList.Rule = variableInitializer
| variableInitializerList
+ ToElement(COMMA)
+ variableInitializer;
var variableInitializerListOptional = new GrammarDefinition("VariableInitializerListOptional",
rule: null | variableInitializerList);
arrayInitializer.Rule = ToElement(OPEN_BRACE)
+ variableInitializerListOptional
+ ToElement(CLOSE_BRACE)
| ToElement(OPEN_BRACE)
+ variableInitializerList
+ ToElement(COMMA)
+ ToElement(CLOSE_BRACE);
arrayInitializer.ComputeResult = node =>
{
var result = new ArrayInitializer();
result.OpeningBrace = node.Children[0].Result;
ParserNode initializersNode = null;
if (node.Children.Count == 4)
{
initializersNode = node.Children[1];
}
else
{
if (node.Children[1].HasChildren)
initializersNode = node.Children[1].Children[0];
}
if (initializersNode != null)
{
foreach (var element in initializersNode.GetAllListAstNodes())
{
if (element is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, element);
else
result.Elements.Add((Expression) element);
}
}
if (node.Children.Count == 4)
result.AddChild(AstNodeTitles.ElementSeparator, node.Children[2].Result);
result.ClosingBrace = node.Children[node.Children.Count - 1].Result;
return result;
};
variableInitializer.Rule = expression
| arrayInitializer
;
var variableType = new GrammarDefinition("VariableType");
variableType.Rule = typeNameExpression | variableType + rankSpecifier | variableType + ToElement(STAR);
variableType.ComputeResult = node =>
{
var type = ToTypeReference((IConvertibleToType) node.Children[0].Result);
if (node.Children.Count > 1)
{
var specifier = node.Children[1].Result as ArrayTypeRankSpecifier;
if (specifier != null)
{
type = new ArrayTypeReference(type, specifier);
}
else
{
type = new PointerTypeReference(type)
{
PointerToken = (AstToken) node.Children[1].Result
};
}
}
return type;
};
// Types are recognized as expressions to prevent a conflict in the grammar.
// TODO: also support array and pointer types.
variableDeclaration.Rule =
variableType
+ variableDeclaratorList;
variableDeclaration.ComputeResult = node =>
{
var result = new VariableDeclarationStatement();
result.VariableType = ToTypeReference((IConvertibleToType)node.Children[0].Result);
foreach (var subNode in node.Children[1].GetAllListAstNodes())
{
if (subNode is AstToken)
result.AddChild(AstNodeTitles.ElementSeparator, subNode);
else
result.Declarators.Add((VariableDeclarator) subNode);
}
return result;
};
statementList.Rule = statement | statementList + statement;
#endregion
#region Root compilation unit
var usingNamespaceDirective = new GrammarDefinition("UsingNamespaceDirective",
rule: ToElement(USING)
+ namespaceOrTypeExpression
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new UsingNamespaceDirective();
result.UsingKeyword = (AstToken) node.Children[0].Result;
result.NamespaceIdentifier = ((IConvertibleToIdentifier) node.Children[1].Result).ToIdentifier();
result.AddChild(AstNodeTitles.Semicolon, node.Children[2].Result);
return result;
});
var usingAliasDirective = new GrammarDefinition("UsingAliasDirective",
rule: ToElement(USING)
+ ToElement(IDENTIFIER)
+ ToElement(EQUALS)
+ typeReference
+ ToElement(SEMICOLON),
createNode: node =>
{
var result = new UsingAliasDirective
{
UsingKeyword = (AstToken) node.Children[0].Result,
AliasIdentifier = ToIdentifier(node.Children[1].Result),
OperatorToken = (AstToken) node.Children[2].Result,
TypeImport = (TypeReference) node.Children[3].Result
};
result.AddChild(AstNodeTitles.Semicolon, node.Children[4].Result);
return result;
});
var usingDirective = new GrammarDefinition("UsingNamespaceDirective",
rule: usingNamespaceDirective | usingAliasDirective);
var usingDirectiveList = new GrammarDefinition("UsingDirectiveList");
usingDirectiveList.Rule = usingDirective | usingDirectiveList + usingDirective;
usingDirectiveListOptional.Rule = null | usingDirectiveList;
var compilationUnit = new GrammarDefinition("CompilationUnit",
rule: usingDirectiveListOptional
+ typeOrNamespaceDeclarationListOptional,
createNode: node =>
{
var result = new CompilationUnit();
if (node.Children[0].HasChildren)
{
result.UsingDirectives.AddRange(node.Children[0].Children[0].GetAllListAstNodes<UsingDirective>());
}
if (node.Children[1].HasChildren)
{
foreach (var subNode in node.Children[1].Children[0].GetAllListAstNodes())
{
var typeDecl = subNode as TypeDeclaration;
if (typeDecl == null)
result.Namespaces.Add((NamespaceDeclaration) subNode);
else
result.Types.Add(typeDecl);
}
}
return result;
});
#endregion
RootDefinitions.Add(DefaultRoot = compilationUnit);
RootDefinitions.Add(MemberDeclarationRule = memberDeclaration);
RootDefinitions.Add(StatementRule = statement);
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
if (!IsClassType(ClassType.Interface) && (methodDeclaration.Modifier & Modifiers.Visibility) == 0)
{
methodDeclaration.Modifier |= Modifiers.Public;
}
if ("Finalize".Equals(methodDeclaration.Name, StringComparison.InvariantCultureIgnoreCase) &&
methodDeclaration.Parameters.Count == 0 &&
methodDeclaration.Modifier == (Modifiers.Protected | Modifiers.Override) &&
methodDeclaration.Body.Children.Count == 1)
{
TryCatchStatement tcs = methodDeclaration.Body.Children[0] as TryCatchStatement;
if (tcs != null &&
tcs.StatementBlock is BlockStatement &&
tcs.CatchClauses.Count == 0 &&
tcs.FinallyBlock is BlockStatement &&
tcs.FinallyBlock.Children.Count == 1)
{
ExpressionStatement se = tcs.FinallyBlock.Children[0] as ExpressionStatement;
if (se != null)
{
InvocationExpression ie = se.Expression as InvocationExpression;
if (ie != null &&
ie.Arguments.Count == 0 &&
ie.TargetObject is MemberReferenceExpression &&
(ie.TargetObject as MemberReferenceExpression).TargetObject is BaseReferenceExpression &&
"Finalize".Equals((ie.TargetObject as MemberReferenceExpression).MemberName, StringComparison.InvariantCultureIgnoreCase))
{
DestructorDeclaration des = new DestructorDeclaration("Destructor", Modifiers.None, methodDeclaration.Attributes);
ReplaceCurrentNode(des);
des.Body = (BlockStatement)tcs.StatementBlock;
return(base.VisitDestructorDeclaration(des, data));
}
}
}
}
if ((methodDeclaration.Modifier & (Modifiers.Static | Modifiers.Extern)) == Modifiers.Static &&
methodDeclaration.Body.Children.Count == 0)
{
foreach (AttributeSection sec in methodDeclaration.Attributes)
{
foreach (Attribute att in sec.Attributes)
{
if ("DllImport".Equals(att.Name, StringComparison.InvariantCultureIgnoreCase))
{
methodDeclaration.Modifier |= Modifiers.Extern;
methodDeclaration.Body = null;
}
}
}
}
if (methodDeclaration.TypeReference.Type != "System.Void" && methodDeclaration.Body.Children.Count > 0)
{
if (IsAssignmentTo(methodDeclaration.Body.Children[methodDeclaration.Body.Children.Count - 1], methodDeclaration.Name))
{
Expression returnValue = GetAssignmentFromStatement(methodDeclaration.Body.Children[methodDeclaration.Body.Children.Count - 1]).Right;
methodDeclaration.Body.Children.RemoveAt(methodDeclaration.Body.Children.Count - 1);
methodDeclaration.Body.Return(returnValue);
}
else
{
ReturnStatementForFunctionAssignment visitor = new ReturnStatementForFunctionAssignment(methodDeclaration.Name);
methodDeclaration.Body.AcceptVisitor(visitor, null);
if (visitor.replacementCount > 0)
{
Expression init;
init = ExpressionBuilder.CreateDefaultValueForType(methodDeclaration.TypeReference);
methodDeclaration.Body.Children.Insert(0, new LocalVariableDeclaration(new VariableDeclaration(FunctionReturnValueName, init, methodDeclaration.TypeReference)));
methodDeclaration.Body.Children[0].Parent = methodDeclaration.Body;
methodDeclaration.Body.Return(new IdentifierExpression(FunctionReturnValueName));
}
}
}
return(base.VisitMethodDeclaration(methodDeclaration, data));
}
public virtual void PostWalk(ExpressionStatement node) { }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
ExpressionStatement o = other as ExpressionStatement;
return(o != null && this.Expression.DoMatch(o.Expression, match));
}
public override void PostWalk(ExpressionStatement node) { }
public void ResolveFieldInitializers (BlockContext ec)
{
Debug.Assert (!IsPartialPart);
if (ec.IsStatic) {
if (initialized_static_fields == null)
return;
bool has_complex_initializer = !ec.Module.Compiler.Settings.Optimize;
int i;
ExpressionStatement [] init = new ExpressionStatement [initialized_static_fields.Count];
for (i = 0; i < initialized_static_fields.Count; ++i) {
FieldInitializer fi = initialized_static_fields [i];
ExpressionStatement s = fi.ResolveStatement (ec);
if (s == null) {
s = EmptyExpressionStatement.Instance;
} else if (!fi.IsSideEffectFree) {
has_complex_initializer = true;
}
init [i] = s;
}
for (i = 0; i < initialized_static_fields.Count; ++i) {
FieldInitializer fi = initialized_static_fields [i];
//
// Need special check to not optimize code like this
// static int a = b = 5;
// static int b = 0;
//
if (!has_complex_initializer && fi.IsDefaultInitializer)
continue;
ec.AssignmentInfoOffset += fi.AssignmentOffset;
ec.CurrentBlock.AddScopeStatement (new StatementExpression (init [i]));
}
return;
}
if (initialized_fields == null)
return;
for (int i = 0; i < initialized_fields.Count; ++i) {
FieldInitializer fi = initialized_fields [i];
//
// Clone before resolving otherwise when field initializer is needed
// in more than 1 constructor any resolve after the initial one would
// only took the resolved expression which is problem for expressions
// that generate extra expressions or code during Resolve phase
//
var cloned = fi.Clone (new CloneContext ());
ExpressionStatement s = fi.ResolveStatement (ec);
if (s == null) {
initialized_fields [i] = new FieldInitializer (fi.Field, ErrorExpression.Instance, Location.Null);
continue;
}
//
// Field is re-initialized to its default value => removed
//
if (fi.IsDefaultInitializer && Kind != MemberKind.Struct && ec.Module.Compiler.Settings.Optimize)
continue;
ec.AssignmentInfoOffset += fi.AssignmentOffset;
ec.CurrentBlock.AddScopeStatement (new StatementExpression (s));
initialized_fields [i] = (FieldInitializer) cloned;
}
}
public void VisitExpressionStatement(ExpressionStatement exprStmt)
{
exprStmt.Expression.AcceptWalker(this);
}
public ExpressionBlock(IEmitter emitter, ExpressionStatement expressionStatement)
: base(emitter, expressionStatement)
{
this.Emitter = emitter;
this.ExpressionStatement = expressionStatement;
}
public override void Complete(CompletionContext context)
{
if (declarationBegin > context.StartOffset) {
base.Complete(context);
return;
}
TypeSystemAstBuilder b = new TypeSystemAstBuilder(contextAtCaret);
b.ShowTypeParameterConstraints = false;
b.GenerateBody = true;
var entityDeclaration = b.ConvertEntity(this.Entity);
entityDeclaration.Modifiers &= ~(Modifiers.Virtual | Modifiers.Abstract);
entityDeclaration.Modifiers |= Modifiers.Override;
var body = entityDeclaration.GetChildByRole(Roles.Body);
Statement baseCallStatement = body.Children.OfType<Statement>().FirstOrDefault();
if (!this.Entity.IsAbstract) {
// modify body to call the base method
if (this.Entity.SymbolKind == SymbolKind.Method) {
var baseCall = new BaseReferenceExpression().Invoke(this.Entity.Name, new Expression[] { });
if (((IMethod)this.Entity).ReturnType.IsKnownType(KnownTypeCode.Void))
baseCallStatement = new ExpressionStatement(baseCall);
else
baseCallStatement = new ReturnStatement(baseCall);
// Clear body of inserted method
entityDeclaration.GetChildByRole(Roles.Body).Statements.Clear();
}
}
var document = context.Editor.Document;
StringWriter w = new StringWriter();
var formattingOptions = FormattingOptionsFactory.CreateSharpDevelop();
var segmentDict = SegmentTrackingOutputFormatter.WriteNode(w, entityDeclaration, formattingOptions, context.Editor.Options);
using (document.OpenUndoGroup()) {
InsertionContext insertionContext = new InsertionContext(context.Editor.GetService(typeof(TextArea)) as TextArea, declarationBegin);
insertionContext.InsertionPosition = context.Editor.Caret.Offset;
string newText = w.ToString().TrimEnd();
document.Replace(declarationBegin, context.EndOffset - declarationBegin, newText);
var throwStatement = entityDeclaration.Descendants.FirstOrDefault(n => n is ThrowStatement);
if (throwStatement != null) {
var segment = segmentDict[throwStatement];
context.Editor.Select(declarationBegin + segment.Offset, segment.Length);
}
CSharpFormatterHelper.Format(context.Editor, declarationBegin, newText.Length, formattingOptions);
var refactoringContext = SDRefactoringContext.Create(context.Editor, CancellationToken.None);
var typeResolveContext = refactoringContext.GetTypeResolveContext();
if (typeResolveContext == null) {
return;
}
var resolvedCurrent = typeResolveContext.CurrentTypeDefinition;
var entities = FindFieldsAndProperties(resolvedCurrent).ToList();
if (entities.Any()) {
IEditorUIService uiService = context.Editor.GetService(typeof(IEditorUIService)) as IEditorUIService;
ITextAnchor endAnchor = context.Editor.Document.CreateAnchor(context.Editor.Caret.Offset);
endAnchor.MovementType = AnchorMovementType.AfterInsertion;
ITextAnchor startAnchor = context.Editor.Document.CreateAnchor(context.Editor.Caret.Offset);
startAnchor.MovementType = AnchorMovementType.BeforeInsertion;
ITextAnchor insertionPos = context.Editor.Document.CreateAnchor(endAnchor.Offset);
insertionPos.MovementType = AnchorMovementType.BeforeInsertion;
AbstractInlineRefactorDialog dialog = new OverrideToStringMethodDialog(insertionContext, context.Editor, insertionPos, entities, baseCallStatement);
dialog.Element = uiService.CreateInlineUIElement(insertionPos, dialog);
insertionContext.RegisterActiveElement(new InlineRefactorSnippetElement(cxt => null, ""), dialog);
} else {
if (baseCallStatement != null) {
// Add default base call
MethodDeclaration insertedOverrideMethod = refactoringContext.GetNode().PrevSibling as MethodDeclaration;
if (insertedOverrideMethod == null)
{
// We are not inside of a method declaration
return;
}
using (Script script = refactoringContext.StartScript()) {
script.AddTo(insertedOverrideMethod.Body, baseCallStatement);
}
}
}
insertionContext.RaiseInsertionCompleted(EventArgs.Empty);
}
}
private static void GenerateExpressionStatement(ScriptGenerator generator, MemberSymbol symbol, ExpressionStatement statement)
{
ScriptTextWriter writer = generator.Writer;
ExpressionGenerator.GenerateExpression(generator, symbol, statement.Expression);
if (statement.IsFragment == false)
{
writer.Write(";");
writer.WriteLine();
}
}
protected override CodeAction GetAction(RefactoringContext context, IfElseStatement node)
{
if (!node.IfToken.Contains(context.Location))
{
return(null);
}
Expression rightSide;
var comparedNode = CheckNode(node, out rightSide);
if (comparedNode == null)
{
return(null);
}
return(new CodeAction(context.TranslateString("Replace with '??'"),
script => {
var previousNode = node.GetPrevSibling(sibling => sibling is Statement);
var previousDeclaration = previousNode as VariableDeclarationStatement;
if (previousDeclaration != null && previousDeclaration.Variables.Count() == 1)
{
var variable = previousDeclaration.Variables.First();
var comparedNodeIdentifierExpression = comparedNode as IdentifierExpression;
if (comparedNodeIdentifierExpression != null &&
comparedNodeIdentifierExpression.Identifier == variable.Name)
{
script.Replace(variable.Initializer, new BinaryOperatorExpression(variable.Initializer.Clone(),
BinaryOperatorType.NullCoalescing,
rightSide.Clone()));
script.Remove(node);
return;
}
}
var previousExpressionStatement = previousNode as ExpressionStatement;
if (previousExpressionStatement != null)
{
var previousAssignment = previousExpressionStatement.Expression as AssignmentExpression;
if (previousAssignment != null &&
comparedNode.IsMatch(previousAssignment.Left))
{
var newExpression = new BinaryOperatorExpression(previousAssignment.Right.Clone(),
BinaryOperatorType.NullCoalescing,
rightSide.Clone());
script.Replace(previousAssignment.Right, newExpression);
script.Remove(node);
return;
}
}
var coalescedExpression = new BinaryOperatorExpression(comparedNode.Clone(),
BinaryOperatorType.NullCoalescing,
rightSide.Clone());
var newAssignment = new ExpressionStatement(new AssignmentExpression(comparedNode.Clone(), coalescedExpression));
script.Replace(node, newAssignment);
}, node));
}
public override bool Walk(ExpressionStatement node)
{
_eval.Evaluate(node.Expression);
return(false);
}