private static INode ModifyLambdaForSelectMany(LambdaExpression lambdaExpression,
ParenthesizedExpression parenthesizedlambdaExpression,
InvocationExpression invocationExpression)
{
INode node = lambdaExpression;
var argPos = invocationExpression.Arguments.IndexOf(lambdaExpression);
switch (argPos)
{
case 0: // first one, select the collection
// need to enter a cast for (IEnumerable<dynamic>) on the end of the lambda body
var selectManyExpression = new LambdaExpression
{
ExpressionBody =
new CastExpression(new TypeReference("IEnumerable<dynamic>"),
new ParenthesizedExpression(lambdaExpression.ExpressionBody), CastType.Cast),
Parameters = lambdaExpression.Parameters,
};
node = new CastExpression(new TypeReference("Func<dynamic, IEnumerable<dynamic>>"),
new ParenthesizedExpression(selectManyExpression), CastType.Cast);
break;
case 1: // the transformation func
node = new CastExpression(new TypeReference("Func<dynamic, dynamic, dynamic>"), parenthesizedlambdaExpression,
CastType.Cast);
break;
}
return node;
}
//, AstExpression expression)
public static InvocationExpression add_Invocation(this BlockStatement blockStatement, string typeName, string methodName, params object[] parameters)
{
if (methodName.valid().isFalse())
return null;
Expression memberExpression = null;
if (typeName.valid())
memberExpression = new MemberReferenceExpression(new IdentifierExpression(typeName), methodName);
else
memberExpression = new IdentifierExpression(methodName);
var memberReference = new InvocationExpression(memberExpression);
if (parameters != null)
{
var arguments = new List<Expression>();
foreach (var parameter in parameters)
if (parameter is Expression)
arguments.add(parameter as Expression);
else
arguments.add(new PrimitiveExpression(parameter, parameter.str()));
memberReference.Arguments = arguments;
}
blockStatement.append(memberReference.expressionStatement());
return memberReference;
}
public override object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
{
const string initializerBlock = "InitializerBlock";
if (constructorDeclaration.Name == initializerBlock)
{
TypeDeclaration type = (TypeDeclaration) constructorDeclaration.Parent;
string initName = "Init" + type.Name;
MethodDeclaration initMethod = GetInitMethod(type);
initMethod.Body.Children.AddRange(constructorDeclaration.Body.Children);
Expression initInvocation = new InvocationExpression(new IdentifierExpression(initName));
ExpressionStatement initInvocationStatement = new ExpressionStatement(initInvocation);
IList constructors = AstUtil.GetChildrenWithType(type, typeof(ConstructorDeclaration));
if (constructors.Count > 1)
{
foreach (ConstructorDeclaration constructor in constructors)
{
if (constructor.Name != initializerBlock && !HasInitInvocation(constructor))
constructor.Body.Children.Insert(0, initInvocationStatement);
}
}
else if (((ConstructorDeclaration) constructors[0]).Name == initializerBlock)
{
ConstructorDeclaration constructor = new ConstructorDeclaration(type.Name, Modifiers.Public, null, null);
constructor.Body = new BlockStatement();
constructor.Body.AddChild(initInvocationStatement);
type.AddChild(constructor);
}
RemoveCurrentNode();
}
return base.TrackedVisitConstructorDeclaration(constructorDeclaration, data);
}
public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
if (invocationExpression.TargetObject is FieldReferenceExpression)
{
FieldReferenceExpression targetObject = (FieldReferenceExpression) invocationExpression.TargetObject;
string methodName = targetObject.FieldName;
TypeDeclaration typeDeclaration = GetEnclosingTypeDeclaration(invocationExpression);
TypeDeclaration thisTypeDeclaration = (TypeDeclaration) AstUtil.GetParentOfType(invocationExpression, typeof(TypeDeclaration));
if (typeDeclaration != null && IsTestFixture(thisTypeDeclaration))
{
IList methods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration));
IList specialMethods = GetMethods(methods, methodName);
if (ContainsInternalMethod(specialMethods))
{
Expression replacedExpression;
MethodDeclaration method = (MethodDeclaration) specialMethods[0];
bool staticMethod = AstUtil.ContainsModifier(method, Modifiers.Static);
replacedExpression = CreateReflectionInvocation(invocationExpression, staticMethod);
if (invocationExpression.Parent is Expression || invocationExpression.Parent is VariableDeclaration)
{
TypeReference returnType = GetInternalMethodReturnType(specialMethods);
CastExpression castExpression = new CastExpression(returnType, replacedExpression, CastType.Cast);
replacedExpression = castExpression;
}
ReplaceCurrentNode(replacedExpression);
}
}
}
return base.TrackedVisitInvocationExpression(invocationExpression, data);
}
public override void GenerateCode(List<AbstractNode> nodes, IList items)
{
TypeReference stringReference = new TypeReference("System.String");
MethodDeclaration method = new MethodDeclaration("ToString",
Modifiers.Public | Modifiers.Override,
stringReference,
null, null);
method.Body = new BlockStatement();
Expression target = new FieldReferenceExpression(new TypeReferenceExpression(stringReference),
"Format");
InvocationExpression methodCall = new InvocationExpression(target);
StringBuilder formatString = new StringBuilder();
formatString.Append('[');
formatString.Append(currentClass.Name);
for (int i = 0; i < items.Count; i++) {
formatString.Append(' ');
formatString.Append(codeGen.GetPropertyName(((FieldWrapper)items[i]).Field.Name));
formatString.Append("={");
formatString.Append(i);
formatString.Append('}');
}
formatString.Append(']');
methodCall.Arguments.Add(new PrimitiveExpression(formatString.ToString(), formatString.ToString()));
foreach (FieldWrapper w in items) {
methodCall.Arguments.Add(new FieldReferenceExpression(new ThisReferenceExpression(), w.Field.Name));
}
method.Body.AddChild(new ReturnStatement(methodCall));
nodes.Add(method);
}
public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
if (invocationExpression.TargetObject is FieldReferenceExpression)
{
FieldReferenceExpression targetObject = (FieldReferenceExpression) invocationExpression.TargetObject;
if (targetObject.FieldName == "toArray" || targetObject.FieldName == "ToArray")
{
Expression invoker = targetObject.TargetObject;
TypeReference invokerType = GetExpressionType(invoker);
if (invokerType != null && collectionTypes.Contains(invokerType.Type))
{
if (invocationExpression.Arguments.Count == 1)
{
Expression argExpression = (Expression) invocationExpression.Arguments[0];
if (argExpression is ArrayCreateExpression)
{
InvocationExpression newInvocation = invocationExpression;
TypeReference old = ((ArrayCreateExpression) argExpression).CreateType;
TypeReference tr = new TypeReference(old.Type);
TypeOfExpression tof = new TypeOfExpression(tr);
tr.Parent = tof;
tof.Parent = newInvocation;
newInvocation.Arguments.Clear();
newInvocation.Arguments.Add(tof);
ReplaceCurrentNode(newInvocation);
}
}
}
}
}
return base.TrackedVisitInvocationExpression(invocationExpression, data);
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
var memberReferenceExpression = invocationExpression.TargetObject as MemberReferenceExpression;
if (memberReferenceExpression == null)
return base.VisitInvocationExpression(invocationExpression, data);
LambdaExpression lambdaExpression;
switch (memberReferenceExpression.MemberName)
{
case "Select":
if (invocationExpression.Arguments.Count != 1)
return base.VisitInvocationExpression(invocationExpression, data);
lambdaExpression = invocationExpression.Arguments[0] as LambdaExpression;
break;
case "SelectMany":
if (invocationExpression.Arguments.Count != 2)
return base.VisitInvocationExpression(invocationExpression, data);
lambdaExpression = invocationExpression.Arguments[1] as LambdaExpression;
break;
default:
return base.VisitInvocationExpression(invocationExpression, data);
}
if (lambdaExpression == null)
return base.VisitInvocationExpression(invocationExpression, data);
ProcessQuery(lambdaExpression.ExpressionBody);
return base.VisitInvocationExpression(invocationExpression, data);
}
public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
Expression invocationTarget = invocationExpression.TargetObject;
if (invocationTarget is FieldReferenceExpression)
{
FieldReferenceExpression methodTargetObject = (FieldReferenceExpression) invocationTarget;
Expression invoker = methodTargetObject.TargetObject;
TypeReference invokerType = GetExpressionType(invoker);
if (invokerType != null)
{
ReplaceMember(invocationExpression, data, invokerType);
}
}
else if (invocationTarget is IdentifierExpression)
{
TypeDeclaration typeDeclaration = (TypeDeclaration) AstUtil.GetParentOfType(invocationExpression, typeof(TypeDeclaration));
VerifyDerivedMethod(typeDeclaration, invocationExpression, data);
}
if (invocationExpression.TypeArguments.Count == 0)
return base.TrackedVisitInvocationExpression(invocationExpression, data);
else
{
invocationExpression.TypeArguments.Clear();
return null;
}
}
void CheckGenericInvoke(InvocationExpression expr)
{
Assert.AreEqual(1, expr.Arguments.Count);
Assert.IsTrue(expr.TargetObject is IdentifierExpression);
Assert.AreEqual("myMethod", ((IdentifierExpression)expr.TargetObject).Identifier);
Assert.AreEqual(1, expr.TypeArguments.Count);
Assert.AreEqual("System.Char", expr.TypeArguments[0].SystemType);
}
public override object VisitInvocationExpression(InvocationExpression invocation, object data)
{
if (GetPrecedence(invocation.TargetObject) >= GetPrecedence(invocation)) {
invocation.TargetObject = Deparenthesize(invocation.TargetObject);
}
for(int i = 0; i < invocation.Arguments.Count; i++) {
invocation.Arguments[i] = Deparenthesize(invocation.Arguments[i]);
}
return base.VisitInvocationExpression(invocation, data);
}
public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
if (invocationExpression.TargetObject is IdentifierExpression)
{
IdentifierExpression identifierExpression = (IdentifierExpression) invocationExpression.TargetObject;
if (Methods.Contains(identifierExpression.Identifier) && data is IList)
((IList) data).Add(invocationExpression);
}
return base.TrackedVisitInvocationExpression(invocationExpression, data);
}
public void MethodOnThisReferenceInvocation()
{
// InitializeComponents();
MemberReferenceExpression field = new MemberReferenceExpression(new ThisReferenceExpression(), "InitializeComponents");
InvocationExpression invocation = new InvocationExpression(field, new List<Expression>());
object output = invocation.AcceptVisitor(new CodeDomVisitor(), null);
Assert.IsTrue(output is CodeMethodInvokeExpression);
CodeMethodInvokeExpression mie = (CodeMethodInvokeExpression)output;
Assert.AreEqual("InitializeComponents", mie.Method.MethodName);
Assert.IsTrue(mie.Method.TargetObject is CodeThisReferenceExpression);
}
public void IdentifierOnlyInvocation()
{
// InitializeComponents();
IdentifierExpression identifier = new IdentifierExpression("InitializeComponents");
InvocationExpression invocation = new InvocationExpression(identifier, new List<Expression>());
object output = invocation.AcceptVisitor(new CodeDomVisitor(), null);
Assert.IsTrue(output is CodeMethodInvokeExpression);
CodeMethodInvokeExpression mie = (CodeMethodInvokeExpression)output;
Assert.AreEqual("InitializeComponents", mie.Method.MethodName);
Assert.IsTrue(mie.Method.TargetObject is CodeThisReferenceExpression);
}
void CheckGenericInvoke2(InvocationExpression expr)
{
Assert.AreEqual(0, expr.Arguments.Count);
Assert.IsTrue(expr.TargetObject is IdentifierExpression);
IdentifierExpression ident = (IdentifierExpression)expr.TargetObject;
Assert.AreEqual("myMethod", ident.Identifier);
Assert.AreEqual(2, ident.TypeArguments.Count);
Assert.AreEqual("T", ident.TypeArguments[0].Type);
Assert.IsFalse(ident.TypeArguments[0].IsKeyword);
Assert.AreEqual("System.Boolean", ident.TypeArguments[1].Type);
Assert.IsTrue(ident.TypeArguments[1].IsKeyword);
}
private InvocationExpression CreateGetClassMethodInvocation(TypeOfExpression typeOfExpression)
{
FieldReferenceExpression argument = new FieldReferenceExpression(typeOfExpression, "AssemblyQualifiedName");
typeOfExpression.Parent = argument;
List<Expression> arguments = new List<Expression>();
arguments.Add(argument);
IdentifierExpression methodIdentifier = new IdentifierExpression("java.lang.Class");
FieldReferenceExpression methodReference = new FieldReferenceExpression(methodIdentifier, "forName");
InvocationExpression invocationExpression = new InvocationExpression(methodReference, arguments);
argument.Parent = invocationExpression;
methodReference.Parent = invocationExpression;
return invocationExpression;
}
public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
if (invocationExpression.TargetObject is IdentifierExpression)
{
TypeDeclaration typeDeclaration = (TypeDeclaration) AstUtil.GetParentOfType(invocationExpression, typeof(TypeDeclaration));
IdentifierExpression methodIdentifier = (IdentifierExpression) invocationExpression.TargetObject;
if (typeDeclaration.Parent is TypeDeclaration)
{
List<ParameterDeclarationExpression> argList = new List<ParameterDeclarationExpression>();
int i = 0;
foreach (Expression argument in invocationExpression.Arguments)
{
TypeReference argumentType = GetExpressionType(argument);
if (argumentType != null)
{
string argType = argumentType.Type;
TypeReference typeReference = new TypeReference(argType);
ParameterDeclarationExpression parameterExpression = new ParameterDeclarationExpression(typeReference, "arg" + i);
parameterExpression.TypeReference.RankSpecifier = new int[0];
i++;
argList.Add(parameterExpression);
}
}
MethodDeclaration argMethod = new MethodDeclaration(methodIdentifier.Identifier, Modifiers.None, null, argList, null);
IList parentMethods = GetAccessibleMethods((TypeDeclaration) typeDeclaration.Parent);
if (Contains(parentMethods, argMethod))
{
int methodIndex = IndexOf(parentMethods, argMethod);
argMethod = (MethodDeclaration) parentMethods[methodIndex];
if (!AstUtil.ContainsModifier(argMethod, Modifiers.Static))
{
string parentTypeName = ((TypeDeclaration) typeDeclaration.Parent).Name;
AddInstanceField(typeDeclaration, parentTypeName);
AddProperConstructor(typeDeclaration, parentTypeName);
FieldReferenceExpression newReference = new FieldReferenceExpression(
new IdentifierExpression(parentTypeName),
((IdentifierExpression) invocationExpression.TargetObject).Identifier);
InvocationExpression newInvication = new InvocationExpression(newReference, invocationExpression.Arguments);
newInvication.Parent = invocationExpression.Parent;
ReplaceCurrentNode(newInvication);
}
}
}
}
return base.TrackedVisitInvocationExpression(invocationExpression, data);
}
public void InvocationOfStaticMethod()
{
// System.Drawing.Color.FromArgb();
MemberReferenceExpression field = new MemberReferenceExpression(new IdentifierExpression("System"), "Drawing");
field = new MemberReferenceExpression(field, "Color");
field = new MemberReferenceExpression(field, "FromArgb");
InvocationExpression invocation = new InvocationExpression(field, new List<Expression>());
object output = invocation.AcceptVisitor(new CodeDomVisitor(), null);
Assert.IsTrue(output is CodeMethodInvokeExpression);
CodeMethodInvokeExpression mie = (CodeMethodInvokeExpression)output;
Assert.AreEqual("FromArgb", mie.Method.MethodName);
Assert.IsTrue(mie.Method.TargetObject is CodeTypeReferenceExpression);
Assert.AreEqual("System.Drawing.Color", (mie.Method.TargetObject as CodeTypeReferenceExpression).Type.BaseType);
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
var expression = invocationExpression.TargetObject as IdentifierExpression;
if(expression == null)
return base.VisitInvocationExpression(invocationExpression, data);
switch (expression.Identifier)
{
case "SpatialGenerate":
throw new InvalidOperationException("SpatialIndex.Generate or SpatialGenerate cannot be used from transform results");
case "CreateField":
throw new InvalidOperationException("CreateField cannot be used from transform results");
}
return base.VisitInvocationExpression(invocationExpression, data);
}
public override object VisitInvocationExpression (InvocationExpression invocationExpression, object data)
{
string invocation = "";
if (!invocationExpression.StartLocation.IsEmpty && !invocationExpression.EndLocation.IsEmpty) {
invocation = this.data.Document.GetTextBetween (this.data.Document.LocationToOffset (invocationExpression.StartLocation.Line, invocationExpression.StartLocation.Column),
this.data.Document.LocationToOffset (invocationExpression.EndLocation.Line, invocationExpression.EndLocation.Column));
}
base.VisitInvocationExpression (invocationExpression, data);
MethodResolveResult mrr = resolver.Resolve (new ExpressionResult (invocation), new DomLocation (invocationExpression.StartLocation.Line, invocationExpression.StartLocation.Column)) as MethodResolveResult;
if (mrr != null && mrr.MostLikelyMethod != null && mrr.MostLikelyMethod is ExtensionMethod) {
IMethod originalMethod = ((ExtensionMethod)mrr.MostLikelyMethod).OriginalMethod;
possibleTypeReferences.Add (new TypeReference (originalMethod.DeclaringType.Name));
}
return null;
}
public override object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data)
{
var expression = namedArgumentExpression.Expression as MemberReferenceExpression;
if (expression == null)
return base.VisitNamedArgumentExpression(namedArgumentExpression, data);
var identifierExpression = expression.TargetObject as IdentifierExpression;
if (identifierExpression == null || identifierExpression.Identifier != identifier)
return base.VisitNamedArgumentExpression(namedArgumentExpression, data);
var right = new InvocationExpression(new MemberReferenceExpression(namedArgumentExpression.Expression, "Unwrap"))
{
Parent = namedArgumentExpression.Expression.Parent
};
namedArgumentExpression.Expression.Parent = right;
namedArgumentExpression.Expression = right;
return base.VisitNamedArgumentExpression(namedArgumentExpression, data);
}
protected static Statement CreateCaller(AttributedNode parent, MethodDeclaration method, VariableDeclaration returnVariable)
{
Statement caller;
InvocationExpression expr = new InvocationExpression(new IdentifierExpression(method.Name), CreateArgumentExpressions(method.Parameters));
if (method.TypeReference.Type != "System.Void") {
TypeReference parentType = GetParentReturnType(parent);
if (method.TypeReference == parentType)
caller = new ReturnStatement(expr);
else {
returnVariable.Initializer = expr;
caller = new LocalVariableDeclaration(returnVariable);
}
} else {
caller = new ExpressionStatement(expr);
}
return caller;
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
var memberReferenceExpression = invocationExpression.TargetObject as MemberReferenceExpression;
if (memberReferenceExpression == null || memberReferenceExpression.MemberName != "Select")
return base.VisitInvocationExpression(invocationExpression, data);
if(invocationExpression.Arguments.Count != 1)
return base.VisitInvocationExpression(invocationExpression, data);
var lambdaExpression = invocationExpression.Arguments[0] as LambdaExpression;
if(lambdaExpression == null)
return base.VisitInvocationExpression(invocationExpression, data);
ProcessQuery(lambdaExpression.ExpressionBody);
return base.VisitInvocationExpression(invocationExpression, data);
}
private void CreateMethodImplementation(MethodDeclaration equalsMethod)
{
string fieldName = "instancehelper_" + equalsMethod.Name;
IdentifierExpression targetObject = new IdentifierExpression("java.lang.Object");
List<Expression> arguments = new List<Expression>();
arguments.Add(new ThisReferenceExpression());
string parameterName = ((ParameterDeclarationExpression) equalsMethod.Parameters[0]).ParameterName;
IdentifierExpression identifier = new IdentifierExpression(parameterName);
arguments.Add(identifier);
FieldReferenceExpression fieldReferenceExpression = new FieldReferenceExpression(targetObject, fieldName);
InvocationExpression invocationExpression = new InvocationExpression(fieldReferenceExpression, arguments);
ReturnStatement returnStatement = new ReturnStatement(invocationExpression);
BlockStatement block = new BlockStatement();
block.Children.Add(returnStatement);
equalsMethod.Body = block;
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
var memberReferenceExpression = invocationExpression.TargetObject as MemberReferenceExpression;
if(memberReferenceExpression != null)
{
if(memberReferenceExpression.MemberName == "Generate")
{
var identifierExpression = memberReferenceExpression.TargetObject as IdentifierExpression;
if (identifierExpression != null && identifierExpression.Identifier == "SpatialIndex")
throw new InvalidOperationException("SpatialIndex.Generate cannot be used from transform results");
}
}
var expression = invocationExpression.TargetObject as IdentifierExpression;
if(expression != null && expression.Identifier == "CreateField")
{
throw new InvalidOperationException("CreateField cannot be used from transform results");
}
return base.VisitInvocationExpression(invocationExpression, data);
}
private bool ContainsMethod(TypeDeclaration typeDeclaration, InvocationExpression invocationExpression)
{
string identifier = null;
if (invocationExpression.TargetObject is IdentifierExpression)
identifier = ((IdentifierExpression) invocationExpression.TargetObject).Identifier;
else if (invocationExpression.TargetObject is FieldReferenceExpression)
identifier = ((FieldReferenceExpression) invocationExpression.TargetObject).FieldName;
IList methods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration));
foreach (MethodDeclaration method in methods)
{
string pascalName = identifier[0].ToString().ToUpper() + identifier.Substring(1);
if ((method.Name == identifier || method.Name == pascalName) && !IsMethodInExternalTypes(typeDeclaration, method))
{
return true;
}
}
return false;
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
IMethodOrProperty m = GetMethod(invocationExpression);
if (m == null) {
// This might also be a delegate invocation:
// get the delegate's Invoke method
IReturnType targetType = invocationExpression.TargetObject.AcceptVisitor(this, data) as IReturnType;
if (targetType != null) {
IClass c = targetType.GetUnderlyingClass();
if (c != null && c.ClassType == ClassType.Delegate) {
// find the delegate's return type
m = c.Methods.Find(delegate(IMethod innerMethod) { return innerMethod.Name == "Invoke"; });
}
}
}
if (m != null)
return m.ReturnType;
else
return null;
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
var memberReferenceExpression = invocationExpression.TargetObject as MemberReferenceExpression;
if(memberReferenceExpression == null)
return base.VisitInvocationExpression(invocationExpression, data);
if(methodNames.Contains(memberReferenceExpression.MemberName) == false)
return base.VisitInvocationExpression(invocationExpression, data);
invocationExpression.Arguments.Insert(0, memberReferenceExpression.TargetObject);
var newInvocation = new InvocationExpression(
new MemberReferenceExpression(
new TypeReferenceExpression(new TypeReference(typeof (DynamicExtensionMethods).FullName)),
memberReferenceExpression.MemberName),
invocationExpression.Arguments
);
ReplaceCurrentNode(newInvocation);
return base.VisitInvocationExpression(invocationExpression, data);
}
public override object VisitInvocationExpression(ICSharpCode.NRefactory.Ast.InvocationExpression invocationExpression, object data)
{
var memberReferenceExpression = invocationExpression.TargetObject as MemberReferenceExpression;
if (memberReferenceExpression == null || memberReferenceExpression.MemberName != "Generate")
{
return(base.VisitInvocationExpression(invocationExpression, data));
}
var identifierExpression = memberReferenceExpression.TargetObject as IdentifierExpression;
if (identifierExpression == null || identifierExpression.Identifier != "SpatialIndex")
{
return(base.VisitInvocationExpression(invocationExpression, data));
}
ReplaceCurrentNode(new InvocationExpression(new IdentifierExpression("SpatialGenerate"), invocationExpression.Arguments));
return(base.VisitInvocationExpression(invocationExpression, data));
}
public static string EvaluateMethodCoupling(InvocationExpression expression, MethodProperties meth)
{
Console.WriteLine(expression.ToString());
meth.EfferentCoupling++;
StringBuilder calleeName = new StringBuilder();
List<string> paramList = new List<string>();
MethodProperties methCallee = null;
lock(coupleLock)
{
if(expression.TargetObject is MemberReferenceExpression) {
calleeName.Append(ExtractCalleeFullName((MemberReferenceExpression)(expression.TargetObject), meth));
paramList = ExtractParamList(expression, meth);
try {
methCallee = ComplexityMetrics.ProjProp.GetMethodReference(calleeName.ToString(), paramList);
methCallee.AfferentCoupling++;
} catch (Exception e) {
Console.WriteLine(e.ToString());
}
} else if (expression.TargetObject is IdentifierExpression) {
calleeName.Append(((IdentifierExpression)expression.TargetObject).Identifier);
paramList = ExtractParamList(expression, meth);
try {
Console.WriteLine(calleeName.ToString());
methCallee = ComplexityMetrics.ProjProp.GetMethodReference(calleeName.ToString(), paramList);
methCallee.AfferentCoupling++;
} catch (Exception e) {
Console.WriteLine(e.ToString());
}
}
}
return methCallee.Method.ReturnType.FullName;
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
base.VisitInvocationExpression(invocationExpression, data);
// Reduce "String.Concat(a, b)" to "a + b"
MemberReferenceExpression target = invocationExpression.TargetObject as MemberReferenceExpression;
if (target != null &&
target.MemberName == "Concat" &&
invocationExpression.Arguments.Count == 2 &&
target.TargetObject is IdentifierExpression &&
(target.TargetObject as IdentifierExpression).Identifier == "String")
{
ReplaceCurrentNode(
new BinaryOperatorExpression(
invocationExpression.Arguments[0],
BinaryOperatorType.Add,
invocationExpression.Arguments[1]
)
);
}
return null;
}
void ReDimClauseInternal(
//#line 3486 "VBNET.ATG"
ref Expression expr) {
//#line 3487 "VBNET.ATG"
List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; Location startLocation = la.Location;
while (la.kind == 26 ||
//#line 3490 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
if (la.kind == 26) {
lexer.NextToken();
IdentifierOrKeyword(
//#line 3489 "VBNET.ATG"
out name);
//#line 3489 "VBNET.ATG"
expr = new MemberReferenceExpression(expr, name) { StartLocation = startLocation, EndLocation = t.EndLocation };
} else {
InvocationExpression(
//#line 3491 "VBNET.ATG"
ref expr);
//#line 3493 "VBNET.ATG"
expr.StartLocation = startLocation;
expr.EndLocation = t.EndLocation;
}
}
Expect(37);
NormalOrReDimArgumentList(
//#line 3498 "VBNET.ATG"
out arguments, out canBeNormal, out canBeRedim);
Expect(38);
//#line 3500 "VBNET.ATG"
expr = new InvocationExpression(expr, arguments);
if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
if (this.Errors.Count == 0) {
// don't recurse on parse errors - could result in endless recursion
ReDimClauseInternal(ref expr);
}
}
}
IEnumerable <Ast.ParameterDeclarationExpression> CreateParameters(UnknownMethodResolveResult rr, ClassFinder context, Ast.InvocationExpression invocation)
{
List <string> usedNames = new List <string>();
for (int i = 0; i < rr.Arguments.Count; i++)
{
IReturnType type = rr.Arguments[i];
if (type is LambdaReturnType)
{
type = (type as LambdaReturnType).ToDefaultDelegate();
}
Ast.TypeReference typeRef = CodeGenerator.ConvertType(type, context);
typeRef = typeRef.IsNull ? new Ast.TypeReference("object", true) : typeRef;
Ast.Expression ex = invocation.Arguments[i];
string paramName = IsNumericType(type) ? "num" + i : type.Name + i.ToString();
if (ex is Ast.IdentifierExpression)
{
paramName = (ex as Ast.IdentifierExpression).Identifier;
}
if (ex is Ast.MemberReferenceExpression)
{
paramName = (ex as Ast.MemberReferenceExpression).MemberName;
}
Ast.ParameterModifiers mod = Ast.ParameterModifiers.None;
if (ex is Ast.DirectionExpression)
{
var dex = ex as Ast.DirectionExpression;
if (dex.Expression is Ast.IdentifierExpression)
{
paramName = (dex.Expression as Ast.IdentifierExpression).Identifier;
}
if (dex.Expression is Ast.MemberReferenceExpression)
{
paramName = (dex.Expression as Ast.MemberReferenceExpression).MemberName;
}
mod = dex.FieldDirection == Ast.FieldDirection.Out ? Ast.ParameterModifiers.Out : (dex.FieldDirection == Ast.FieldDirection.Ref ? Ast.ParameterModifiers.Ref : Ast.ParameterModifiers.None);
}
paramName = rr.CallingClass.ProjectContent.Language.CodeGenerator.GetParameterName(paramName);
if (usedNames.Contains(paramName))
{
paramName += i.ToString();
}
usedNames.Add(paramName);
yield return(new Ast.ParameterDeclarationExpression(typeRef, paramName)
{
ParamModifier = mod
});
}
}