private static PythonNode Wrap(ConstantExpression exp, PythonNode parent)
{
return(new ConstantExpressionNode(exp)
{
Parent = parent, Value = exp.Value
});
}
public bool Similar(PythonNode node1)
{
var node = InnerNode.NodeName + ": " + Value;
var compared = node1.InnerNode.NodeName + ": " + node1.Value;
return(node.Equals(compared));
}
private void Write(PythonNode stmt, bool notlambda = true)
{
if (stmt is PythonAstNode)
{
Write(stmt as PythonAstNode);
}
else if (stmt is SuiteStatementNode)
{
Write(stmt as SuiteStatementNode);
}
else if (stmt is ExpressionStatementNode)
{
Write(stmt as ExpressionStatementNode, notlambda);
}
else if (stmt is NameExpressionNode)
{
Write(stmt as NameExpressionNode);
}
else if (stmt is OrExpressionNode)
{
Write((OrExpressionNode)stmt);
}
else
{
throw new NotImplementedException(stmt.GetType().ToString());
}
}
private static PythonNode Wrap(NameExpression exp, PythonNode parent)
{
return(new NameExpressionNode(exp)
{
Parent = parent, Value = exp.Name
});
}
private static PythonNode Wrap(Statement stmt, PythonNode parent)
{
if (stmt is SuiteStatement)
{
return(Wrap(stmt as SuiteStatement, parent));
}
if (stmt is ExpressionStatement)
{
return(Wrap(stmt as ExpressionStatement, parent));
}
/*
* if (stmt is FunctionDefinition) return Wrap(stmt as FunctionDefinition, parent);
* if (stmt is FromImportStatement) return Wrap(stmt as FromImportStatement, parent);
* if (stmt is ReturnStatement) return Wrap(stmt as ReturnStatement, parent);
* if (stmt is IfStatement) return Wrap(stmt as IfStatement, parent);
* if (stmt is AssignmentStatement) return Wrap(stmt as AssignmentStatement, parent);
* if (stmt is AugmentedAssignStatement) return Wrap(stmt as AugmentedAssignStatement, parent);
* if (stmt is ForStatement) return Wrap(stmt as ForStatement, parent);
* if (stmt is WhileStatement) return Wrap(stmt as WhileStatement, parent);
* if (stmt is ImportStatement) return Wrap(stmt as ImportStatement, parent);
* if (stmt is PrintStatement) return Wrap(stmt as PrintStatement, parent);
*/
throw new NotImplementedException(stmt.NodeName);
}
private static PythonNode Wrap(Expression exp, PythonNode parent)
{
if (exp is NameExpression)
{
return(Wrap(exp as NameExpression, parent));
}
if (exp is BinaryExpression)
{
return(Wrap(exp as BinaryExpression, parent));
}
if (exp is ConstantExpression)
{
return(Wrap(exp as ConstantExpression, parent));
}
if (exp is CallExpression)
{
return(Wrap(exp as CallExpression, parent));
}
if (exp is TupleExpression)
{
return(Wrap(exp as TupleExpression, parent));
}
if (exp is ParenthesisExpression)
{
return(Wrap((ParenthesisExpression)exp, parent));
}
if (exp is MemberExpression)
{
return(Wrap((MemberExpression)exp, parent));
}
if (exp is IndexExpression)
{
return(Wrap((IndexExpression)exp, parent));
}
if (exp is LambdaExpression)
{
return(Wrap((LambdaExpression)exp, parent));
}
if (exp is OrExpression)
{
return(Wrap((OrExpression)exp, parent));
}
if (exp is UnaryExpression)
{
return(Wrap((UnaryExpression)exp, parent));
}
if (exp is ListExpression)
{
return(Wrap((ListExpression)exp, parent));
}
if (exp is ListComprehension)
{
return(Wrap((ListComprehension)exp, parent));
}
if (exp is ConditionalExpression)
{
return(Wrap((ConditionalExpression)exp, parent));
}
throw new NotImplementedException("Wrapper not implemened : " + exp.Type);
}
private static PythonNode Wrap(FunctionDefinition stmt, PythonNode parent)
{
var result = new FunctionDefinitionNode(stmt)
{
Parent = parent
};
if (!stmt.Name.IsNullOrEmpty())
{
result.Value = stmt.Name;
}
if (stmt.Decorators != null)
{
foreach (var exp in stmt.Decorators)
{
result.AddChild(Wrap(exp, result));
}
}
foreach (var param in stmt.Parameters)
{
result.AddChild(Wrap(param, result));
}
result.AddChild(Wrap(stmt.Body, result));
return(result);
}
public virtual void Insert(PythonNode inserted, int index)
{
if (InsertStrategy == null)
{
throw new TransformationNotApplicableExpection();
}
Children = InsertStrategy.Insert(this, inserted, index);
}
public override PythonNode Apply(PythonNode node)
{
var newList = new List <PythonNode>();
newList.AddRange(node.Children);
node.Children = newList.Where(e => e.Id != ModifiedNode.Id).ToList();
return(node);
}
public bool Visit(PythonNode pythonNode)
{
if (pythonNode is FunctionDefinitionNode &&
pythonNode.Value != null && Equals(pythonNode.Value, _name))
{
Function = pythonNode;
}
return(Function == null);
}
public static NodeInfo CreateInfo(PythonNode node)
{
var type = node.GetType().Name;
dynamic nodeValue;
switch (type)
{
case "FunctionDefinitionNode":
nodeValue = ((FunctionDefinition)node.InnerNode).Name;
break;
case "ConstantExpressionNode":
nodeValue = ((ConstantExpression)node.InnerNode).Value;
break;
case "AugmentedAssignStatementNode":
nodeValue = ((AugmentedAssignStatement)node.InnerNode).Operator;
break;
case "BinaryExpressionNode":
nodeValue = ((BinaryExpression)node.InnerNode).Operator;
break;
case "NameExpressionNode":
nodeValue = ((NameExpression)node.InnerNode).Name;
break;
case "TupleExpressionNode":
nodeValue = ((TupleExpression)node.InnerNode).IsExpandable;
break;
case "ParameterNode":
nodeValue = ((Parameter)node.InnerNode).Name;
break;
case "ArgNode":
case "CallExpressionNode":
case "LambdaExpressionNode":
case "SuiteStatementNode":
case "IfStatementNode":
case "IfStatementTestNode":
case "AssignmentStatementNode":
case "ReturnStatementNode":
case "ExpressionStatementNode":
case "WhileStatementNode":
case "ParenthesisExpressionNode":
case "ForStatementNode":
case "ConditionalExpressionNode":
nodeValue = null;
break;
default:
throw new NotImplementedException();
}
return(nodeValue == null ? new NodeInfo(type) : new NodeInfo(type, nodeValue));
}
private static PythonNode Wrap(ParenthesisExpression exp, PythonNode parent)
{
var result = new ParenthesisExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Expression, result));
return(result);
}
private static PythonNode Wrap(ImportStatement stmt, PythonNode parent)
{
var result = new ImportStatementNode(stmt)
{
Parent = parent
};
result.Names = stmt.AsNames;
return(result);
}
private static PythonNode Wrap(Arg arg, PythonNode parent)
{
var result = new ArgNode(arg)
{
Parent = parent, Value = arg.Name
};
result.AddChild(Wrap(arg.Expression, result));
return(result);
}
private static PythonNode Wrap(LambdaExpression exp, PythonNode parent)
{
var result = new LambdaExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Function, result));
return(result);
}
private static PythonNode Wrap(ListExpression exp, PythonNode parent)
{
var result = new ListExpressionNode(exp)
{
Parent = parent
};
exp.Items.ForEach(e => result.AddChild(Wrap(e, result)));
return(result);
}
private static PythonNode Wrap(MemberExpression exp, PythonNode parent)
{
var result = new MemberExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Target, result));
result.Value = exp.Name;
return(result);
}
private static PythonNode Wrap(IfStatementTest test, PythonNode parent)
{
var result = new IfStatementTestNode(test)
{
Parent = parent
};
result.AddChild(Wrap(test.Test, result));
result.AddChild(Wrap(test.Body, result));
return(result);
}
private static PythonNode Wrap(UnaryExpression exp, PythonNode parent)
{
var result = new UnaryExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Expression, result));
result.Value = exp.Op;
return(result);
}
private static PythonNode Wrap(BinaryExpression exp, PythonNode parent)
{
var result = new BinaryExpressionNode(exp)
{
Parent = parent, Value = exp.Operator
};
result.AddChild(Wrap(exp.Left, result));
result.AddChild(Wrap(exp.Right, result));
return(result);
}
private static PythonNode Wrap(OrExpression exp, PythonNode parent)
{
var result = new OrExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Left, result));
result.AddChild(Wrap(exp.Right, result));
return(result);
}
private bool CheckTemplate(PythonNode node)
{
var result = _template.Match(node);
if (result.Item1)
{
HasMatch = true;
MatchResult = result.Item2;
return(false);
}
return(!_exact);
}
private static PythonNode Wrap(AugmentedAssignStatement stmt, PythonNode parent)
{
var result = new AugmentedAssignStatementNode(stmt)
{
Parent = parent, Value = stmt.Operator.ToString()
};
result.AddChild(Wrap(stmt.Left, result));
result.AddChild(Wrap(stmt.Right, result));
result.Value = stmt.Operator;
return(result);
}
public bool Visit(PythonNode pythonNode)
{
foreach (var operation in _operations)
{
if (pythonNode.Equals(operation.ModifiedNode))
{
SubOperations.Add(operation);
return(true);
}
}
return(false);
}
protected override void GenerateNodes(PythonNode t1, PythonNode t2)
{
var visitor = new SortedTreeVisitor();
t1.PostWalk(visitor);
A = visitor.Nodes;
T1 = Enumerable.Range(1, A.Count).ToArray();
visitor = new SortedTreeVisitor();
t2.PostWalk(visitor);
B = visitor.Nodes;
T2 = Enumerable.Range(1, B.Count).ToArray();
}
private static PythonNode Wrap(SuiteStatement stmt, PythonNode parent)
{
var result = new SuiteStatementNode(stmt)
{
Parent = parent
};
foreach (var statement in stmt.Statements)
{
result.AddChild(Wrap(statement, result));
}
return(result);
}
public bool CheckStaticTests(PythonNode changedProgram, Tuple <string, List <string> > staticTests)
{
var findFunctionVisitor = new FindFunctionVisitor(staticTests.Item1);
changedProgram.Walk(findFunctionVisitor);
if (findFunctionVisitor.Function != null)
{
var visitor = new StaticAnalysisTester(staticTests);
findFunctionVisitor.Function.Walk(visitor);
return(visitor.Passed);
}
return(false);
}
private static PythonNode Wrap(ReturnStatement stmt, PythonNode parent)
{
var result = new ReturnStatementNode(stmt)
{
Parent = parent
};
if (stmt.Expression != null)
{
result.AddChild(Wrap(stmt.Expression, result));
}
return(result);
}
private static PythonNode Wrap(Parameter parameter, PythonNode parent)
{
var result = new ParameterNode(parameter)
{
Parent = parent, Value = parameter.Name
};
if (parameter.DefaultValue != null)
{
result.AddChild(Wrap(parameter.DefaultValue, result));
}
result.Value = parameter.Name;
return(result);
}
private static PythonNode Wrap(TupleExpression exp, PythonNode parent)
{
var result = new TupleExpressionNode(exp)
{
Parent = parent
};
result.Value = exp.IsExpandable;
foreach (var item in exp.Items)
{
result.AddChild(Wrap(item, result));
}
return(result);
}
