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 TrackedVisitTypeReference(TypeReference typeReference, object data)
{
string name = typeReference.Type;
if (name.IndexOf('.') != -1)
Add(name);
return base.TrackedVisitTypeReference(typeReference, data);
}
void CreateDelegate(DefaultClass c, string name, AST.TypeReference returnType, IList <AST.TemplateDefinition> templates, IList <AST.ParameterDeclarationExpression> parameters)
{
c.BaseTypes.Add(c.ProjectContent.SystemTypes.Delegate);
if (currentClass.Count > 0)
{
DefaultClass cur = GetCurrentClass();
cur.InnerClasses.Add(c);
c.FullyQualifiedName = cur.FullyQualifiedName + '.' + name;
}
else
{
c.FullyQualifiedName = PrependCurrentNamespace(name);
cu.Classes.Add(c);
}
c.UsingScope = currentNamespace;
currentClass.Push(c); // necessary for CreateReturnType
ConvertTemplates(templates, c);
List <IParameter> p = new List <IParameter>();
if (parameters != null)
{
foreach (AST.ParameterDeclarationExpression param in parameters)
{
p.Add(CreateParameter(param));
}
}
AnonymousMethodReturnType.AddDefaultDelegateMethod(c, CreateReturnType(returnType), p);
currentClass.Pop();
}
public LocalLookupVariable(TypeReference typeRef, Location startPos, Location endPos, bool isConst)
{
this.typeRef = typeRef;
this.startPos = startPos;
this.endPos = endPos;
this.isConst = isConst;
}
public static VariableDeclaration add_Variable(this BlockStatement blockDeclaration, string name, Expression expression, TypeReference typeReference)
{
var variableDeclaration = new VariableDeclaration(name, expression) {TypeReference = typeReference};
var localVariableDeclaration = new LocalVariableDeclaration(variableDeclaration);
blockDeclaration.append(localVariableDeclaration);
return variableDeclaration;
}
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 static MethodDeclaration add_Method(this TypeDeclaration typeDeclaration, string methodName, Dictionary<string, object> invocationParameters, BlockStatement body)
{
var newMethod = new MethodDeclaration
{
Name = methodName,
//Modifier = Modifiers.None | Modifiers.Public | Modifiers.Static,
Modifier = Modifiers.None | Modifiers.Public,
Body = body
};
newMethod.setReturnType();
if (invocationParameters != null)
foreach (var invocationParameter in invocationParameters)
{
var parameterType = new TypeReference(
(invocationParameter.Value != null && invocationParameter.Key != "returnData")
? invocationParameter.Value.typeFullName()
: "System.Object", true);
var parameter = new ParameterDeclarationExpression(parameterType, invocationParameter.Key);
newMethod.Parameters.Add(parameter);
}
typeDeclaration.AddChild(newMethod);
return newMethod;
}
/// <summary>
/// Adds a <see cref="ParameterDeclarationExpression"/> to <see cref="ParametrizedNode.Parameters"/> in a single
/// call, for convenience.
/// </summary>
///
/// <param name="node">
/// The method or constructor to add the parameter to.
/// </param>
///
/// <param name="parameterType">
/// The <see cref="TypeReference"/> of the parameter to add.
/// </param>
///
/// <param name="parameterName">
/// The name of the parameter to add.
/// </param>
///
/// <returns>
/// The <see cref="ParameterDeclarationExpression"/> instance that was created and added to
/// <paramref name="node"/>.
/// </returns>
public static ParameterDeclarationExpression AddParameter(this ParametrizedNode node,
TypeReference parameterType, string parameterName)
{
var parameter = new ParameterDeclarationExpression(parameterType, parameterName);
node.Parameters.Add(parameter);
return parameter;
}
public static IReturnType CreateReturnType(TypeReference reference, NRefactoryResolver resolver)
{
return CreateReturnType(reference,
resolver.CallingClass, resolver.CallingMember,
resolver.CaretLine, resolver.CaretColumn,
resolver.ProjectContent, ReturnTypeOptions.None);
}
public static Expression CreateDefaultValueForType(TypeReference type)
{
if (type != null && !type.IsArrayType) {
switch (type.Type) {
case "System.SByte":
case "System.Byte":
case "System.Int16":
case "System.UInt16":
case "System.Int32":
case "System.UInt32":
case "System.Int64":
case "System.UInt64":
case "System.Single":
case "System.Double":
return new PrimitiveExpression(0, "0");
case "System.Char":
return new PrimitiveExpression('\0', "'\\0'");
case "System.Object":
case "System.String":
return new PrimitiveExpression(null, "null");
case "System.Boolean":
return new PrimitiveExpression(false, "false");
default:
return new DefaultValueExpression(type);
}
} else {
return new PrimitiveExpression(null, "null");
}
}
public HasAssignmentsVisitor(string name, TypeReference type, Location startRange, Location endRange)
{
this.name = name;
this.type = type;
this.startRange = startRange;
this.endRange = endRange;
}
public override object TrackedVisitBlockStatement(BlockStatement blockStatement, object data)
{
blockStatement.Children.Clear();
TypeReference notImplmentedException = new TypeReference("System.NotImplementedException");
ObjectCreateExpression objectCreate = new ObjectCreateExpression(notImplmentedException, new List<Expression>());
blockStatement.Children.Add(new ThrowStatement(objectCreate));
return null;
}
bool IsIn(TypeReference type, List<TypeReference> list)
{
foreach (TypeReference tr in list) {
if (tr.Type == type.Type)
return true;
}
return false;
}
public void HasReturnValue_HasOne()
{
var methodToTest = new MethodDeclaration();
var retval = new TypeReference("string", new[] { 0 });
methodToTest.TypeReference = retval;
var victim = new TestableMethodTemplate(methodToTest, null);
Assert.IsTrue(victim.HasReturnValue);
}
public TypeReference[] GetArgumentTypes(string sig)
{
Match m = methodRegex.Match(sig);
int count = m.Groups["param"].Captures.Count;
TypeReference[] arguments = new TypeReference[count];
for (int i = 0; i < count; i++)
arguments[i] = GetTypeReference(m.Groups["param"].Captures[i].Value);
return arguments;
}
public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass,
IMember callingMember, int caretLine, int caretColumn,
IProjectContent projectContent,
bool useLazyReturnType)
{
return CreateReturnType(reference, callingClass, callingMember, caretLine, caretColumn,
projectContent,
useLazyReturnType ? ReturnTypeOptions.Lazy : ReturnTypeOptions.None);
}
public void HasReturnValue_HasVoid()
{
var methodToTest = new MethodDeclaration();
var retval = new TypeReference("void");
methodToTest.TypeReference = retval;
var victim = new TestableMethodTemplate(methodToTest, null);
Assert.IsFalse(victim.HasReturnValue);
}
public TypeReference GetTypeReference(string val)
{
string type = val.TrimStart('[', 'L').Replace("$", ".").TrimEnd(';');
if (types.Contains(type))
type = (string) types[type];
TypeReference typeRef = new TypeReference(type);
if (val.StartsWith("["))
typeRef.RankSpecifier = new int[1] {0};
return typeRef;
}
public LocalLookupVariable(string name, TypeReference typeRef, Location startPos, Location endPos, bool isConst, bool isLoopVariable, Expression initializer)
{
this.Name = name;
this.TypeRef = typeRef;
this.StartPos = startPos;
this.EndPos = endPos;
this.IsConst = isConst;
this.IsLoopVariable = isLoopVariable;
this.Initializer = initializer;
}
static IReturnType CreateReturnType(AST.TypeReference reference, IMethod method, IClass currentClass, ICompilationUnit cu, TypeVisitor.ReturnTypeOptions options)
{
if (currentClass == null)
{
return(TypeVisitor.CreateReturnType(reference, new DefaultClass(cu, "___DummyClass"), method, 1, 1, cu.ProjectContent, options | TypeVisitor.ReturnTypeOptions.Lazy));
}
else
{
return(TypeVisitor.CreateReturnType(reference, currentClass, method, currentClass.Region.BeginLine + 1, 1, cu.ProjectContent, options | TypeVisitor.ReturnTypeOptions.Lazy));
}
}
public override object VisitTypeReference(TypeReference typeReference, object data)
{
var withinRange = _column >= typeReference.StartLocation.Column && _column < typeReference.StartLocation.Column + typeReference.Type.Length;
if (typeReference.StartLocation.Line == _line && withinRange)
{
Found = typeReference.Type;
return(true);
}
return(base.VisitTypeReference(typeReference, data));
}
public LocalLookupVariable(string name, TypeReference typeRef, Location startPos, Location endPos, bool isConst, bool isLoopVariable, Expression initializer, LambdaExpression parentLambdaExpression, bool isQueryContinuation)
{
this.Name = name;
this.TypeRef = typeRef;
this.StartPos = startPos;
this.EndPos = endPos;
this.IsConst = isConst;
this.IsLoopVariable = isLoopVariable;
this.Initializer = initializer;
this.ParentLambdaExpression = parentLambdaExpression;
this.IsQueryContinuation = isQueryContinuation;
}
string GetDotNetNameFromTypeReference(TypeReference type)
{
string name;
InnerClassTypeReference ictr = type as InnerClassTypeReference;
if (ictr != null) {
name = GetDotNetNameFromTypeReference(ictr.BaseType) + "+" + ictr.Type;
} else {
name = type.Type;
}
if (type.GenericTypes.Count != 0)
name = name + "`" + type.GenericTypes.Count.ToString();
return name;
}
public void AddVariable(TypeReference typeRef, string name, Location startPos, Location endPos, bool isConst)
{
if (name == null || name.Length == 0) {
return;
}
List<LocalLookupVariable> list;
if (!variables.ContainsKey(name)) {
variables[name] = list = new List<LocalLookupVariable>();
} else {
list = (List<LocalLookupVariable>)variables[name];
}
list.Add(new LocalLookupVariable(typeRef, startPos, endPos, isConst));
}
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);
}
private Expression GetReplacedExpression(TypeReference typeReference)
{
TypeOfExpression typeOfExpression = new TypeOfExpression(typeReference);
Expression replacedExpression = typeOfExpression;
if (Mode == "IKVM")
{
InvocationExpression methodInvocation = CreateGetClassMethodInvocation(typeOfExpression);
replacedExpression = methodInvocation;
}
replacedExpression.Parent = typeReference.Parent.Parent;
return replacedExpression;
}
public override object TrackedVisitTypeReference(TypeReference typeReference, object data)
{
string type = typeReference.Type;
if (type.StartsWith("System.") && typeReference.Parent != null)
{
string name = type.Substring(type.LastIndexOf('.') + 1);
TypeReference newTypeReference = typeReference;
newTypeReference.Type = name;
ReplaceCurrentNode(newTypeReference);
AddUsing(typeReference, data, type);
}
return null;
}
public void AddVariable(TypeReference typeRef, string name,
Location startPos, Location endPos, bool isConst,
bool isLoopVariable, Expression initializer,
LambdaExpression parentLambdaExpression)
{
if (name == null || name.Length == 0) {
return;
}
List<LocalLookupVariable> list;
if (!variables.ContainsKey(name)) {
variables[name] = list = new List<LocalLookupVariable>();
} else {
list = (List<LocalLookupVariable>)variables[name];
}
list.Add(new LocalLookupVariable(name, typeRef, startPos, endPos, isConst, isLoopVariable, initializer, parentLambdaExpression));
}
public override void GenerateCode(List<AbstractNode> nodes, IList items)
{
TypeReference intReference = new TypeReference("System.Int32");
MethodDeclaration method = new MethodDeclaration("GetHashCode", Modifiers.Public | Modifiers.Override, intReference, null, null);
Expression expr = CallGetHashCode(new IdentifierExpression(currentClass.Fields[0].Name));
for (int i = 1; i < currentClass.Fields.Count; i++) {
IdentifierExpression identifier = new IdentifierExpression(currentClass.Fields[i].Name);
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.ExclusiveOr,
CallGetHashCode(identifier));
}
method.Body = new BlockStatement();
method.Body.AddChild(new ReturnStatement(expr));
nodes.Add(method);
TypeReference boolReference = new TypeReference("System.Boolean");
TypeReference objectReference = new TypeReference("System.Object");
method = new MethodDeclaration("Equals", Modifiers.Public | Modifiers.Override, boolReference, null, null);
method.Parameters.Add(new ParameterDeclarationExpression(objectReference, "obj"));
method.Body = new BlockStatement();
TypeReference currentType = ConvertType(currentClass.DefaultReturnType);
expr = new TypeOfIsExpression(new IdentifierExpression("obj"), currentType);
expr = new ParenthesizedExpression(expr);
expr = new UnaryOperatorExpression(expr, UnaryOperatorType.Not);
method.Body.AddChild(new IfElseStatement(expr, new ReturnStatement(new PrimitiveExpression(false, "false"))));
expr = new BinaryOperatorExpression(new ThisReferenceExpression(),
BinaryOperatorType.Equality,
new IdentifierExpression("obj"));
method.Body.AddChild(new IfElseStatement(expr, new ReturnStatement(new PrimitiveExpression(true, "true"))));
VariableDeclaration var = new VariableDeclaration("my" + currentClass.Name,
new CastExpression(currentType, new IdentifierExpression("obj"), CastType.Cast),
currentType);
method.Body.AddChild(new LocalVariableDeclaration(var));
expr = TestEquality(var.Name, currentClass.Fields[0]);
for (int i = 1; i < currentClass.Fields.Count; i++) {
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.LogicalAnd,
TestEquality(var.Name, currentClass.Fields[i]));
}
method.Body.AddChild(new ReturnStatement(expr));
nodes.Add(method);
}
public override object VisitTypeReference(TypeReference typeReference, object data)
{
string fullName = typeReference.Type;
string shortName = GetShortName(fullName);
if (shortName != null) {
typeReference.Type = shortName;
return null;
}
if (fullName.EndsWith("[]")) {
shortName = GetShortName(fullName.Replace("[]",""));
if (shortName != null) {
typeReference.Type = shortName + "[]";
return null;
}
}
return null;
}
/// <summary>
/// Provides a mechanism for making a <see cref="ConstructorDeclaration"/> a bit more like a
/// <see cref="MethodDeclaration"/> by simulating a common method for the result of their respective executions.
/// </summary>
///
/// <param name="node">
/// A constructor or method.
/// </param>
///
/// <param name="parentType">
/// The <see cref="TypeDeclaration"/> in which the constructor or method denoted by <paramref name="node"/> can
/// be found.
/// </param>
///
/// <returns>
/// A <see cref="TypeReference"/>, if one could be determined; otherwise <see cref="NullTypeReference"/>.
/// </returns>
public static TypeReference GetTypeReference(this ParametrizedNode node, TypeDeclaration parentType)
{
var result = TypeReference.Null;
var method = node as MethodDeclaration;
if(method != null)
{
result = method.TypeReference;
}
else
{
var constructor = node as ConstructorDeclaration;
if (constructor != null)
{
result = new TypeReference(parentType.Name);
}
}
return result;
}
public void MethodInDefaultType()
{
string program = TestUtil.StatementParse("getClass();");
string expected = TestUtil.CSharpStatementParse("java.lang.Object.instancehelper_getClass(this);");
CompilationUnit cu = TestUtil.ParseProgram(program);
NamespaceDeclaration ns = (NamespaceDeclaration) cu.Children[0];
TypeDeclaration type = (TypeDeclaration) ns.Children[0];
TypeReference objectType = new TypeReference("java.lang.Object");
type.BaseTypes.Add(objectType);
CodeBase.Types.Clear();
CodeBase.Types.Add("Test.Test", type);
VisitCompilationUnit(cu, null);
RemoveBaseTypeFrom(type, objectType);
TestUtil.CodeEqual(expected, TestUtil.GenerateCode(cu));
}
public static TypeReference ConvertToTypeReference (this MonoDevelop.Projects.Dom.IReturnType returnType)
{
List<TypeReference> genericTypes = new List<TypeReference> ();
foreach (MonoDevelop.Projects.Dom.IReturnType genericType in returnType.GenericArguments) {
genericTypes.Add (ConvertToTypeReference (genericType));
}
TypeReference result = new TypeReference (returnType.FullName, genericTypes);
result.IsKeyword = true;
result.PointerNestingLevel = returnType.PointerNestingLevel;
if (returnType.ArrayDimensions > 0) {
int[] rankSpecfier = new int[returnType.ArrayDimensions];
for (int i = 0; i < returnType.ArrayDimensions; i++) {
rankSpecfier[i] = returnType.GetDimension (i);
}
result.RankSpecifier = rankSpecfier;
}
return result;
}
IReturnType CreateReturnType(AST.TypeReference reference)
{
return(CreateReturnType(reference, null, TypeVisitor.ReturnTypeOptions.None));
}
IReturnType CreateReturnType(AST.TypeReference reference, IMethod method, TypeVisitor.ReturnTypeOptions options)
{
return(CreateReturnType(reference, method, GetCurrentClass(), cu, options));
}
internal void ExecuteIntroduceMethod(UnknownMethodResolveResult rr, Ast.Expression invocationExpr, ITextEditor editor, bool isNew, object result)
{
IClass targetClass = IsEqualClass(rr.CallingClass, rr.Target.GetUnderlyingClass()) ? rr.CallingClass
: rr.Target.GetUnderlyingClass();
CodeGenerator gen = targetClass.ProjectContent.Language.CodeGenerator;
IAmbience ambience = targetClass.ProjectContent.Language.GetAmbience();
ClassFinder finder = new ClassFinder(rr.CallingMember);
ModifierEnum modifiers = ModifierEnum.None;
bool isExtension = !targetClass.IsUserCode();
if (IsEqualClass(rr.CallingClass, targetClass))
{
if (rr.CallingMember != null)
{
modifiers |= (rr.CallingMember.Modifiers & ModifierEnum.Static);
}
}
else
{
if (isExtension)
{
if (isNew)
{
targetClass = rr.CallingClass;
}
else
{
targetClass = result as IClass;
}
}
// exclude in Unit Test mode
if (WorkbenchSingleton.Workbench != null)
{
editor = (FileService.OpenFile(targetClass.CompilationUnit.FileName) as ITextEditorProvider).TextEditor;
}
if (targetClass.ClassType != ClassType.Interface)
{
modifiers |= ModifierEnum.Public;
}
if (rr.IsStaticContext)
{
modifiers |= ModifierEnum.Static;
}
}
NRefactoryResolver resolver = Extensions.CreateResolverForContext(targetClass.ProjectContent.Language, editor);
IReturnType type = resolver.GetExpectedTypeFromContext(invocationExpr);
Ast.TypeReference typeRef = CodeGenerator.ConvertType(type, finder);
if (typeRef.IsNull)
{
if (invocationExpr.Parent is Ast.ExpressionStatement)
{
typeRef = new Ast.TypeReference("void", true);
}
else
{
typeRef = new Ast.TypeReference("object", true);
}
}
Ast.MethodDeclaration method = new Ast.MethodDeclaration {
Name = rr.CallName,
Modifier = CodeGenerator.ConvertModifier(modifiers, finder),
TypeReference = typeRef,
Parameters = CreateParameters(rr, finder, invocationExpr as Ast.InvocationExpression).ToList(),
};
if (targetClass.ClassType != ClassType.Interface)
{
method.Body = CodeGenerator.CreateNotImplementedBlock();
}
RefactoringDocumentAdapter documentWrapper = new RefactoringDocumentAdapter(editor.Document);
if (isExtension)
{
method.Parameters.Insert(0, new Ast.ParameterDeclarationExpression(CodeGenerator.ConvertType(rr.Target, finder), "thisInstance"));
method.IsExtensionMethod = true;
method.Modifier |= Ast.Modifiers.Static;
}
if (isNew)
{
Ast.TypeDeclaration newType = new Ast.TypeDeclaration(isExtension ? Ast.Modifiers.Static : Ast.Modifiers.None, null);
newType.Name = result as string;
newType.AddChild(method);
gen.InsertCodeAfter(targetClass, documentWrapper, newType);
}
else
{
if (IsEqualClass(rr.CallingClass, targetClass))
{
gen.InsertCodeAfter(rr.CallingMember, documentWrapper, method);
}
else
{
gen.InsertCodeAtEnd(targetClass.BodyRegion, documentWrapper, method);
}
}
if (targetClass.ClassType == ClassType.Interface)
{
return;
}
ParseInformation info = ParserService.ParseFile(targetClass.CompilationUnit.FileName);
if (info != null)
{
IMember newMember;
if (isNew)
{
targetClass = info.CompilationUnit.Classes.FirstOrDefault(c => c.DotNetName == c.Namespace + "." + (result as string));
}
else
{
targetClass = info.CompilationUnit.Classes.Flatten(c => c.InnerClasses).FirstOrDefault(c => c.DotNetName == targetClass.DotNetName);
}
if (targetClass == null)
{
return;
}
if (IsEqualClass(rr.CallingClass, targetClass))
{
newMember = targetClass.GetInnermostMember(editor.Caret.Line, editor.Caret.Column);
newMember = targetClass.AllMembers
.OrderBy(m => m.BodyRegion.BeginLine)
.ThenBy(m2 => m2.BodyRegion.BeginColumn)
.First(m3 => m3.BodyRegion.BeginLine > newMember.BodyRegion.BeginLine);
}
else
{
newMember = targetClass.Methods.Last();
}
IDocumentLine line = editor.Document.GetLine(newMember.BodyRegion.BeginLine + 2);
int indentLength = DocumentUtilitites.GetWhitespaceAfter(editor.Document, line.Offset).Length;
editor.Select(line.Offset + indentLength, "throw new NotImplementedException();".Length);
}
}
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
});
}
}
IReturnType CreateReturnType(AST.TypeReference reference, IMethod method)
{
return(CreateReturnType(reference, method, GetCurrentClass(), cu));
}
IReturnType CreateReturnType(AST.TypeReference reference)
{
return(CreateReturnType(reference, null));
}