public Candidate(IMethodOrProperty method) { if (method == null) throw new ArgumentNullException("method"); this.Method = method; this.OriginalMethod = method; }
public static void AddContentsFromCalling(ArrayList result, IClass callingClass, IMember callingMember) { IMethodOrProperty methodOrProperty = callingMember as IMethodOrProperty; if (methodOrProperty != null) { foreach (IParameter p in methodOrProperty.Parameters) { result.Add(new DefaultField.ParameterField(p.ReturnType, p.Name, methodOrProperty.Region, callingClass)); } if (callingMember is IMethod) { AddTypeParametersForCtrlSpace(result, ((IMethod)callingMember).TypeParameters); } } bool inStatic = false; if (callingMember != null) { inStatic = callingMember.IsStatic; } if (callingClass != null) { AddTypeParametersForCtrlSpace(result, callingClass.TypeParameters); ArrayList members = new ArrayList(); IReturnType t = callingClass.DefaultReturnType; members.AddRange(t.GetMethods()); members.AddRange(t.GetFields()); members.AddRange(t.GetEvents()); members.AddRange(t.GetProperties()); foreach (IMember m in members) { if ((!inStatic || m.IsStatic) && m.IsAccessible(callingClass, true)) { result.Add(m); } } members.Clear(); IClass c = callingClass.DeclaringType; while (c != null) { t = c.DefaultReturnType; members.AddRange(t.GetMethods()); members.AddRange(t.GetFields()); members.AddRange(t.GetEvents()); members.AddRange(t.GetProperties()); c = c.DeclaringType; } foreach (IMember m in members) { if (m.IsStatic) { result.Add(m); } } } }
public static MethodMapping methodMapping(this O2MappedAstData astData, IMethodOrProperty iMethodOrProperty, INode iNode, string key) { string parentMethod = astData.parentMethodSignature(iNode); string parentClass = astData.parentClassSignature(iNode); return(astData.methodMapping(iMethodOrProperty.fullName(), key, parentMethod, parentClass, iNode)); }
static void TryAddExtension(LanguageProperties language, ArrayList res, IMethodOrProperty ext, IReturnType resolvedType) { // now add the extension method if it fits the type if (MemberLookupHelper.IsApplicable(resolvedType, ext.Parameters[0].ReturnType, ext as IMethod)) { IMethod method = ext as IMethod; if (method != null && method.TypeParameters.Count > 0) { IReturnType[] typeArguments = new IReturnType[method.TypeParameters.Count]; MemberLookupHelper.InferTypeArgument(method.Parameters[0].ReturnType, resolvedType, typeArguments); for (int i = 0; i < typeArguments.Length; i++) { if (typeArguments[i] != null) { ext = (IMethod)ext.CreateSpecializedMember(); ext.ReturnType = ConstructedReturnType.TranslateType(ext.ReturnType, typeArguments, true); for (int j = 0; j < ext.Parameters.Count; ++j) { ext.Parameters[j].ReturnType = ConstructedReturnType.TranslateType(ext.Parameters[j].ReturnType, typeArguments, true); } break; } } } res.Add(ext); } }
void AddParameters(IMethodOrProperty target, ParameterDefinitionCollection plist) { foreach (ParameterDefinition par in plist) { IReturnType pReturnType = CreateType(this.ProjectContent, target, par.ParameterType); DefaultParameter p = new DefaultParameter(par.Name, pReturnType, DomRegion.Empty); if ((par.Attributes & ParameterAttributes.Out) == ParameterAttributes.Out) { p.Modifiers = ParameterModifiers.Out; } else if (par.ParameterType is ReferenceType) { p.Modifiers = ParameterModifiers.Ref; } else { p.Modifiers = ParameterModifiers.In; } if ((par.Attributes & ParameterAttributes.Optional) == ParameterAttributes.Optional) { p.Modifiers |= ParameterModifiers.Optional; } if (p.ReturnType.IsArrayReturnType) { foreach (CustomAttribute att in par.CustomAttributes) { if (att.Constructor.DeclaringType.FullName == typeof(ParamArrayAttribute).FullName) { p.Modifiers |= ParameterModifiers.Params; } } } target.Parameters.Add(p); } }
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 static FilePosition GetEndPosition(this IMethodOrProperty method) { if (method.DeclaringTypeIsInterface()) { return(method.Region.ToEndPosition(method.CompilationUnit)); } return(method.BodyRegion.ToEndPosition(method.CompilationUnit)); }
public static string fullName(this IMethodOrProperty iMethodOrProperty) { if (iMethodOrProperty is IMethod) return (iMethodOrProperty as IMethod).fullName(); else if (iMethodOrProperty is IProperty) return (iMethodOrProperty as IProperty).fullName(); return "[null value]"; }
public Candidate(IMethodOrProperty method) { if (method == null) { throw new ArgumentNullException("method"); } this.Method = method; this.OriginalMethod = method; }
public static bool HasTypeParameters(this IMethodOrProperty methodOrProperty) { var method = methodOrProperty as IMethod; if ((method != null) && (method.TypeParameters != null)) { return(method.TypeParameters.Count > 0); } return(false); }
public static bool IsConstructor(this IMethodOrProperty methodOrProperty) { var method = methodOrProperty as IMethod; if (method != null) { return(method.IsConstructor); } return(false); }
public static void AddContentsFromCalling(List <ICompletionEntry> result, IClass callingClass, IMember callingMember) { IMethodOrProperty methodOrProperty = callingMember as IMethodOrProperty; if (methodOrProperty != null) { foreach (IParameter p in methodOrProperty.Parameters) { result.Add(new DefaultField.ParameterField(p.ReturnType, p.Name, methodOrProperty.Region, callingClass)); } if (callingMember is IMethod) { AddTypeParametersForCtrlSpace(result, ((IMethod)callingMember).TypeParameters); } } bool inStatic = false; if (callingMember != null) { inStatic = callingMember.IsStatic; } if (callingClass != null) { AddTypeParametersForCtrlSpace(result, callingClass.TypeParameters); List <ICompletionEntry> members = new List <ICompletionEntry>(); IReturnType t = callingClass.DefaultReturnType; var language = callingClass.ProjectContent.Language; foreach (IMember m in MemberLookupHelper.GetAccessibleMembers(t, callingClass, language, true)) { if ((!inStatic || m.IsStatic) && language.ShowMember(m, m.IsStatic)) { result.Add(m); } } members.Clear(); IClass c = callingClass.DeclaringType; while (c != null) { t = c.DefaultReturnType; foreach (IMember m in MemberLookupHelper.GetAccessibleMembers(t, c, language, true)) { if (language.ShowMember(m, true)) { result.Add(m); } } c = c.DeclaringType; } } }
public static string fullName(this IMethodOrProperty iMethodOrProperty) { if (iMethodOrProperty is IMethod) { return((iMethodOrProperty as IMethod).fullName()); } else if (iMethodOrProperty is IProperty) { return((iMethodOrProperty as IProperty).fullName()); } return("[null value]"); }
IInsightWindow ShowInsight(ITextEditor editor, IList <IInsightItem> insightItems, ICollection <ResolveResult> parameters, char charTyped) { int paramCount = parameters.Count; if (insightItems == null || insightItems.Count == 0) { return(null); } bool overloadIsSure; int defaultIndex; if (insightItems.Count == 1) { overloadIsSure = true; defaultIndex = 0; } else { var methods = insightItems.Select(item => GetMethodFromInsightItem(item)).ToList(); IReturnType[] argumentTypes = new IReturnType[paramCount + 1]; int i = 0; foreach (ResolveResult rr in parameters) { if (rr != null) { argumentTypes[i] = rr.ResolvedType; } i++; } IMethodOrProperty result = OverloadResolution.FindOverload(methods.Where(m => m != null), argumentTypes, true, false, out overloadIsSure); defaultIndex = methods.IndexOf(result); } IInsightWindow insightWindow = editor.ShowInsightWindow(insightItems); if (insightWindow != null) { InitializeOpenedInsightWindow(editor, insightWindow); insightWindow.SelectedItem = insightItems[defaultIndex]; } if (overloadIsSure) { IMethodOrProperty method = GetMethodFromInsightItem(insightItems[defaultIndex]); if (method != null && paramCount < method.Parameters.Count) { IParameter param = method.Parameters[paramCount]; ProvideContextCompletion(editor, param.ReturnType, charTyped); } } return(insightWindow); }
private NewEventHandlerCompletionItem GenerateCreateNewMember(IMethodOrProperty delegateSignature, ResolveResult resolveResult) { var parametersAsString = GenerateParametersString(DefaulAmbience, delegateSignature); var callingClass = resolveResult.CallingClass; var inStatic = false; if (_resolveResult.CallingMember != null) { inStatic = _resolveResult.CallingMember.IsStatic; } var eventHandlerFullyQualifiedTypeName = FullyQualifiedAmbience.Convert(_resolvedReturnType); var newHandlerName = BuildHandlerName(); if (newHandlerName == null) { var mrr = _resolveResult as MemberResolveResult; var eventMember = (mrr != null ? mrr.ResolvedMember as IEvent : null); newHandlerName = ((callingClass != null) ? callingClass.Name : "callingClass") + "_" + ((eventMember != null) ? eventMember.Name : "eventMember"); } var newHandlerCodeBuilder = new StringBuilder(); newHandlerCodeBuilder.AppendLine().AppendLine(); if (inStatic) { newHandlerCodeBuilder.Append("static "); } newHandlerCodeBuilder .Append(FullyQualifiedAmbience.Convert(delegateSignature.ReturnType)).Append(" ").Append(newHandlerName).Append("(") .Append(parametersAsString).AppendLine(")") .AppendLine("{") .AppendLine("\t") .Append("}"); var createNewMethod = new NewEventHandlerCompletionItem("generate " + newHandlerName + "(...);", newHandlerName, newHandlerName.Length, newHandlerName.Length, "new " + eventHandlerFullyQualifiedTypeName + "(" + newHandlerName + ")\nGenerate new handler\n" + CodeCompletionItem.GetDescription(_resolvedClass), _resolveResult, newHandlerCodeBuilder.ToString()); return(createNewMethod); }
static void TryAddExtension(LanguageProperties language, ArrayList res, IMethodOrProperty ext, IReturnType resolvedType) { // accept only extension methods if (!ext.IsExtensionMethod) { return; } // don't add extension if method with that name already exists // but allow overloading extension methods foreach (IMember member in res) { IMethodOrProperty p = member as IMethodOrProperty; if (p != null && p.IsExtensionMethod) { continue; } if (language.NameComparer.Equals(member.Name, ext.Name)) { return; } } // now add the extension method if it fits the type if (MemberLookupHelper.ConversionExists(resolvedType, ext.Parameters[0].ReturnType)) { IMethod method = ext as IMethod; if (method != null && method.TypeParameters.Count > 0) { IReturnType[] typeArguments = new IReturnType[method.TypeParameters.Count]; MemberLookupHelper.InferTypeArgument(method.Parameters[0].ReturnType, resolvedType, typeArguments); for (int i = 0; i < typeArguments.Length; i++) { if (typeArguments[i] != null) { ext = (IMethod)ext.Clone(); ext.ReturnType = ConstructedReturnType.TranslateType(ext.ReturnType, typeArguments, true); for (int j = 0; j < ext.Parameters.Count; ++j) { ext.Parameters[j].ReturnType = ConstructedReturnType.TranslateType(ext.Parameters[j].ReturnType, typeArguments, true); } break; } } } res.Add(ext); } }
/// <summary> /// For methods having a params-array as last parameter, expand the params array to /// n parameters of the element type and add those as new candidates. /// Mark candidates with the wrong parameter count as Status.WrongParameterCount. /// </summary> void ConstructExpandedForms() { LogStep("Step 1 (Construct expanded forms)"); foreach (Candidate candidate in candidates.ToArray()) { if (candidate.Status == CandidateStatus.Success) { if (candidate.Parameters.Count > 0 && arguments.Count >= candidate.Parameters.Count - 1) { IParameter lastParameter = candidate.Parameters[candidate.Parameters.Count - 1]; if (lastParameter.IsParams && lastParameter.ReturnType.IsArrayReturnType) { // try to construct an expanded form with the correct parameter count IReturnType elementType = lastParameter.ReturnType.CastToArrayReturnType().ArrayElementType; IMethodOrProperty expanded = (IMethodOrProperty)candidate.Method.CreateSpecializedMember(); expanded.Parameters.RemoveAt(candidate.Parameters.Count - 1); int index = 0; while (expanded.Parameters.Count < arguments.Count) { expanded.Parameters.Add(new DefaultParameter(lastParameter.Name + (index++), elementType, lastParameter.Region)); } candidates.Add(new Candidate(expanded) { IsExpanded = true, OriginalMethod = candidate.Method }); } } if (allowAdditionalArguments) { if (candidate.Parameters.Count < arguments.Count) { candidate.Status = CandidateStatus.WrongParameterCount; } } else { if (candidate.Parameters.Count != arguments.Count) { candidate.Status = CandidateStatus.WrongParameterCount; } } } } }
IParameter SearchMethodParameter(string parameter) { IMethodOrProperty method = callingMember as IMethodOrProperty; if (method == null) { return(null); } foreach (IParameter p in method.Parameters) { if (IsSameName(p.Name, parameter)) { return(p); } } return(null); }
protected void ShowInsight(SharpDevelopTextAreaControl editor, MethodInsightDataProvider dp, ICollection <ResolveResult> parameters, char charTyped) { int paramCount = parameters.Count; dp.SetupDataProvider(editor.FileName, editor.ActiveTextAreaControl.TextArea); List <IMethodOrProperty> methods = dp.Methods; if (methods.Count == 0) { return; } bool overloadIsSure; if (methods.Count == 1) { overloadIsSure = true; dp.DefaultIndex = 0; } else { IReturnType[] argumentTypes = new IReturnType[paramCount + 1]; int i = 0; foreach (ResolveResult rr in parameters) { if (rr != null) { argumentTypes[i] = rr.ResolvedType; } i++; } IMethodOrProperty result = Dom.CSharp.OverloadResolution.FindOverload( methods, argumentTypes, true, false, out overloadIsSure); dp.DefaultIndex = methods.IndexOf(result); } editor.ShowInsightWindow(dp); if (overloadIsSure) { IMethodOrProperty method = methods[dp.DefaultIndex]; if (paramCount < method.Parameters.Count) { IParameter param = method.Parameters[paramCount]; ProvideContextCompletion(editor, param.ReturnType, charTyped); } } }
static bool IsSimilarMemberInternal(IMember member1, IMember member2) { if (member1 == member2) { return(true); } if (member1 == null || member2 == null) { return(false); } if (member1.FullyQualifiedName != member2.FullyQualifiedName) { return(false); } if (member1.IsStatic != member2.IsStatic) { return(false); } IMethodOrProperty m1 = member1 as IMethodOrProperty; IMethodOrProperty m2 = member2 as IMethodOrProperty; if (m1 != null || m2 != null) { if (m1 != null && m2 != null) { if (DiffUtility.Compare(m1.Parameters, m2.Parameters) != 0) { return(false); } if (m1 is IMethod && m2 is IMethod) { if ((m1 as IMethod).TypeParameters.Count != (m2 as IMethod).TypeParameters.Count) { return(false); } } } else { return(false); } } return(true); }
IMethodOrProperty ResolveCurrentMember(IClass callingClass) { //LoggingService.DebugFormatted("Getting current method... caretLine = {0}, caretColumn = {1}", caretLine, caretColumn); if (callingClass == null) { return(null); } IMethodOrProperty best = null; int line = 0; foreach (IMethod m in callingClass.Methods) { if (m.Region.BeginLine <= caretLine && m.Region.BeginLine > line) { line = m.Region.BeginLine; best = m; } } foreach (IProperty m in callingClass.Properties) { if (m.Region.BeginLine <= caretLine && m.Region.BeginLine > line) { line = m.Region.BeginLine; best = m; } } if (callingClass.Region.IsEmpty) { // maybe we are in Main method? foreach (IMethod m in callingClass.Methods) { if (m.Region.IsEmpty && !m.IsSynthetic) { // the main method if (best == null || best.BodyRegion.EndLine < caretLine) { return(m); } } } } return(best); }
bool Initialize(ParseInformation parseInfo, int caretLine, int caretColumn) { if (parseInfo == null) { return(false); } this.cu = parseInfo.MostRecentCompilationUnit; if (cu == null) { return(false); } this.pc = cu.ProjectContent; this.caretLine = caretLine; this.caretColumn = caretColumn; this.callingClass = GetCallingClass(pc); callingMember = ResolveCurrentMember(callingClass); if (callingMember == null) { if (cu != parseInfo.BestCompilationUnit) { IClass olderClass = GetCallingClass(parseInfo.BestCompilationUnit.ProjectContent); if (olderClass != null && callingClass == null) { this.callingClass = olderClass; } callingMember = ResolveCurrentMember(olderClass); } } if (callingMember != null) { if (caretLine > callingMember.BodyRegion.EndLine) { this.caretLine = callingMember.BodyRegion.EndLine; this.caretColumn = callingMember.BodyRegion.EndColumn - 1; } else if (caretLine == callingMember.BodyRegion.EndLine && caretColumn >= callingMember.BodyRegion.EndColumn) { this.caretColumn = callingMember.BodyRegion.EndColumn - 1; } } return(true); }
protected void ShowInsight(SharpDevelopTextAreaControl editor, MethodInsightDataProvider dp, ICollection <ResolveResult> parameters, char charTyped) { int paramCount = parameters.Count; dp.SetupDataProvider(editor.FileName, editor.ActiveTextAreaControl.TextArea); List <IMethodOrProperty> methods = dp.Methods; if (methods.Count == 0) { return; } bool overloadIsSure; if (methods.Count == 1) { overloadIsSure = true; dp.DefaultIndex = 0; } else { IReturnType[] parameterTypes = new IReturnType[paramCount + 1]; int i = 0; foreach (ResolveResult rr in parameters) { if (rr != null) { parameterTypes[i] = rr.ResolvedType; } i++; } IReturnType[][] tmp; int[] ranking = MemberLookupHelper.RankOverloads(methods, parameterTypes, true, out overloadIsSure, out tmp); bool multipleBest = false; int bestRanking = -1; int best = 0; for (i = 0; i < ranking.Length; i++) { if (ranking[i] > bestRanking) { bestRanking = ranking[i]; best = i; multipleBest = false; } else if (ranking[i] == bestRanking) { multipleBest = true; } } if (multipleBest) { overloadIsSure = false; } dp.DefaultIndex = best; } editor.ShowInsightWindow(dp); if (overloadIsSure) { IMethodOrProperty method = methods[dp.DefaultIndex]; if (paramCount < method.Parameters.Count) { IParameter param = method.Parameters[paramCount]; ProvideContextCompletion(editor, param.ReturnType, charTyped); } } }
void AddParameters(IMethodOrProperty target, Collection<ParameterDefinition> plist) { foreach (ParameterDefinition par in plist) { IReturnType pReturnType = CreateType(this.ProjectContent, target, par.ParameterType); DefaultParameter p = new DefaultParameter(par.Name, pReturnType, DomRegion.Empty); if (par.ParameterType is ByReferenceType) { if ((par.Attributes & ParameterAttributes.Out) == ParameterAttributes.Out) { p.Modifiers = ParameterModifiers.Out; } else { p.Modifiers = ParameterModifiers.Ref; } } else { p.Modifiers = ParameterModifiers.In; } if ((par.Attributes & ParameterAttributes.Optional) == ParameterAttributes.Optional) { p.Modifiers |= ParameterModifiers.Optional; } if (p.ReturnType.IsArrayReturnType) { foreach (CustomAttribute att in par.CustomAttributes) { if (att.Constructor.DeclaringType.FullName == typeof(ParamArrayAttribute).FullName) { p.Modifiers |= ParameterModifiers.Params; } } } target.Parameters.Add(p); } }
/// <summary> /// Gets which function member is better. (§ 14.4.2.2) /// </summary> /// <param name="arguments">The arguments passed to the function</param> /// <param name="m1">The first method</param> /// <param name="parameters1">The expanded and substituted parameters of the first method</param> /// <param name="m2">The second method</param> /// <param name="parameters2">The expanded and substituted parameters of the second method</param> /// <returns>0 if neither method is better. 1 if m1 is better. 2 if m2 is better.</returns> static int GetBetterFunctionMember(IReturnType[] arguments, IMethodOrProperty m1, IReturnType[] parameters1, bool isExpanded1, IMethodOrProperty m2, IReturnType[] parameters2, bool isExpanded2) { int length = Math.Min(Math.Min(parameters1.Length, parameters2.Length), arguments.Length); bool foundBetterParamIn1 = false; bool foundBetterParamIn2 = false; for (int i = 0; i < length; i++) { if (arguments[i] == null) continue; int res = GetBetterConversion(arguments[i], parameters1[i], parameters2[i]); if (res == 1) foundBetterParamIn1 = true; if (res == 2) foundBetterParamIn2 = true; } if (foundBetterParamIn1 && !foundBetterParamIn2) return 1; if (foundBetterParamIn2 && !foundBetterParamIn1) return 2; if (foundBetterParamIn1 && foundBetterParamIn2) return 0; // ambigous // If none conversion is better than any other, it is possible that the // expanded parameter lists are the same: for (int i = 0; i < length; i++) { if (!object.Equals(parameters1[i], parameters2[i])) { // if expanded parameters are not the same, neither function member is better return 0; } } // the expanded parameters are the same, apply the tie-breaking rules from the spec: // if one method is generic and the other non-generic, the non-generic is better bool m1IsGeneric = (m1 is IMethod) ? ((IMethod)m1).TypeParameters.Count > 0 : false; bool m2IsGeneric = (m2 is IMethod) ? ((IMethod)m2).TypeParameters.Count > 0 : false; if (m1IsGeneric && !m2IsGeneric) return 2; if (m2IsGeneric && !m1IsGeneric) return 1; // for params parameters: non-expanded calls are better if (isExpanded1 && !isExpanded2) return 2; if (isExpanded2 && !isExpanded1) return 1; // if the number of parameters is different, the one with more parameters is better // this occurs when only when both methods are expanded if (m1.Parameters.Count > m2.Parameters.Count) return 1; if (m2.Parameters.Count > m1.Parameters.Count) return 2; IReturnType[] m1ParamTypes = new IReturnType[m1.Parameters.Count]; IReturnType[] m2ParamTypes = new IReturnType[m2.Parameters.Count]; for (int i = 0; i < m1ParamTypes.Length; i++) { m1ParamTypes[i] = m1.Parameters[i].ReturnType; m2ParamTypes[i] = m2.Parameters[i].ReturnType; } return GetMoreSpecific(m1ParamTypes, m2ParamTypes); }
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult) { string expression = expressionResult.Expression; if (callingClass == null) { return(null); } int pos = expression.IndexOf('('); if (pos >= 0) { expression = expression.Substring(0, pos); } expression = expression.Trim(); if (!callingClass.BodyRegion.IsInside(caretLine, caretColumn) && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name)) { return(new TypeResolveResult(callingClass, callingMember, callingClass)); } if (expressionResult.Context != ExpressionContext.Type) { if (callingMember != null && !callingMember.BodyRegion.IsInside(caretLine, caretColumn) && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name)) { return(new MemberResolveResult(callingClass, callingMember, callingMember)); } } return(null); }
public Candidate(IMethodOrProperty method) { this.Method = method; this.OriginalMethod = method; }
public Candidate(IMethodOrProperty method) { this.Method = method; this.OriginalMethod = method; }
public static FilePosition GetStartPosition(this IMethodOrProperty method) { return(method.Region.ToStartPosition(method.CompilationUnit)); }
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult) { string expression = expressionResult.Expression; if (expression == null) return null; if (callingClass == null) return null; int pos = expression.IndexOf('('); if (pos >= 0) { expression = expression.Substring(0, pos); } expression = expression.Trim(); // if (!callingClass.BodyRegion.IsInside(caretLine, caretColumn) // && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name)) // { // return new TypeResolveResult(callingClass, callingMember, callingClass); // } if (expressionResult.Context != ExpressionContext.Type) { if (callingMember != null && !callingMember.BodyRegion.IsInside(caretLine, caretColumn) && (callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name) || // For constructor definition, the expression is the constructor name (e.g. "MyClass") but the name of the member is "#ctor" (callingMember.Name == "#ctor" && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name)) ) ) { return new MemberResolveResult(callingClass, callingMember, callingMember); } } return null; }
internal static void AddParameters(AST.ParameterDeclarationCollection parameters, IList<IParameter> output, IMethodOrProperty method, IClass c) { if (c == null) throw new ArgumentNullException("c"); DefaultParameter p = null; foreach (AST.ParameterDeclaration par in parameters) { p = new DefaultParameter(par.Name, CreateReturnType(par.Type, c, method as IMethod, c.Region.BeginLine + 1, 1, c.ProjectContent), new DomRegion(par.LexicalInfo.Line, par.LexicalInfo.Column)); if (par.IsByRef) p.Modifiers |= ParameterModifiers.Ref; output.Add(p); } if (parameters.HasParamArray) { p.Modifiers |= ParameterModifiers.Params; } }
public static IReturnType CreateReturnType(AST.TypeReference reference, IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, IProjectContent projectContent) { System.Diagnostics.Debug.Assert(projectContent != null); if (reference == null) { return(GetDefaultReturnType(projectContent)); } if (reference is AST.ArrayTypeReference) { AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference; return(new ArrayReturnType(projectContent, CreateReturnType(arr.ElementType, callingClass, callingMember, caretLine, caretColumn, projectContent), (arr.Rank != null) ? (int)arr.Rank.Value : 1)); } else if (reference is AST.SimpleTypeReference) { string name = ((AST.SimpleTypeReference)reference).Name; IReturnType rt; int typeParameterCount = (reference is AST.GenericTypeReference) ? ((AST.GenericTypeReference)reference).GenericArguments.Count : 0; if (name == "duck") { rt = new BooResolver.DuckClass(new DefaultCompilationUnit(projectContent)).DefaultReturnType; } else if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name)) { rt = new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], typeParameterCount); } else if (callingClass == null) { rt = new GetClassReturnType(projectContent, name, typeParameterCount); } else { rt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, name, typeParameterCount); } if (typeParameterCount > 0) { AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments; // GenericTypeReference derives from SimpleTypeReference IReturnType[] typeArguments = new IReturnType[arguments.Count]; for (int i = 0; i < typeArguments.Length; i++) { typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn, projectContent); } rt = new ConstructedReturnType(rt, typeArguments); } return(rt); } else if (reference is AST.CallableTypeReference) { AST.CallableTypeReference ctr = (AST.CallableTypeReference)reference; AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(projectContent)); if (ctr.ReturnType != null) { amrt.MethodReturnType = CreateReturnType(ctr.ReturnType, callingClass, callingMember, caretLine, caretColumn, projectContent); } amrt.MethodParameters = new List <IParameter>(); AddParameters(ctr.Parameters, amrt.MethodParameters, callingMember, callingClass ?? new DefaultClass(new DefaultCompilationUnit(projectContent), "__Dummy")); return(amrt); } else { throw new NotSupportedException("unknown reference type: " + reference.ToString()); } }
public static IReturnType CreateReturnType(AST.TypeReference reference, IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, IProjectContent projectContent) { System.Diagnostics.Debug.Assert(projectContent != null); if (reference == null) { return GetDefaultReturnType(projectContent); } if (reference is AST.ArrayTypeReference) { AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference; return new ArrayReturnType(projectContent, CreateReturnType(arr.ElementType, callingClass, callingMember, caretLine, caretColumn, projectContent), (arr.Rank != null) ? (int)arr.Rank.Value : 1); } else if (reference is AST.SimpleTypeReference) { string name = ((AST.SimpleTypeReference)reference).Name; IReturnType rt; int typeParameterCount = (reference is AST.GenericTypeReference) ? ((AST.GenericTypeReference)reference).GenericArguments.Count : 0; if (name == "duck") rt = new BooResolver.DuckClass(new DefaultCompilationUnit(projectContent)).DefaultReturnType; else if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name)) rt = new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], typeParameterCount); else if (callingClass == null) rt = new GetClassReturnType(projectContent, name, typeParameterCount); else rt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, name, typeParameterCount); if (typeParameterCount > 0) { AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments; // GenericTypeReference derives from SimpleTypeReference IReturnType[] typeArguments = new IReturnType[arguments.Count]; for (int i = 0; i < typeArguments.Length; i++) { typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn, projectContent); } rt = new ConstructedReturnType(rt, typeArguments); } return rt; } else if (reference is AST.CallableTypeReference) { AST.CallableTypeReference ctr = (AST.CallableTypeReference)reference; AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(projectContent)); if (ctr.ReturnType != null) { amrt.MethodReturnType = CreateReturnType(ctr.ReturnType, callingClass, callingMember, caretLine, caretColumn, projectContent); } amrt.MethodParameters = new List<IParameter>(); AddParameters(ctr.Parameters, amrt.MethodParameters, callingMember, callingClass ?? new DefaultClass(new DefaultCompilationUnit(projectContent), "__Dummy")); return amrt; } else { throw new NotSupportedException("unknown reference type: " + reference.ToString()); } }
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult) { try { string expression = expressionResult.Expression; if (callingClass == null) return null; int pos = expression.IndexOf('('); if (pos >= 0) { expression = expression.Substring(0, pos); } expression = expression.Trim(); // if (!callingClass.BodyRegion.IsInside(caretLine, caretColumn) // && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name)) // { // return new TypeResolveResult(callingClass, callingMember, callingClass); // } if (expressionResult.Context != ExpressionContext.Type) { if (callingMember != null && !callingMember.BodyRegion.IsInside(caretLine, caretColumn) && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name)) { return new MemberResolveResult(callingClass, callingMember, callingMember); } } } catch (Exception ex) { PublicDI.log.ex(ex, "in CtrlSpaceResolverHelper.GetResultFromDeclarationLine"); } return null; }
public static bool DeclaringTypeIsInterface(this IMethodOrProperty method) { return(method.DeclaringType.ClassType == ClassType.Interface); }
public static MethodMapping methodMapping(this O2MappedAstData astData, IMethodOrProperty iMethodOrProperty, INode iNode, string key) { string parentMethod = astData.parentMethodSignature(iNode); string parentClass = astData.parentClassSignature(iNode); return astData.methodMapping(iMethodOrProperty.fullName(),key, parentMethod, parentClass, iNode); }
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, string expression) { return(GetResultFromDeclarationLine(callingClass, callingMember, caretLine, caretColumn, new ExpressionResult(expression))); }
bool Initialize(ParseInformation parseInfo, int caretLine, int caretColumn) { if (parseInfo == null) { return false; } this.cu = parseInfo.CompilationUnit; if (cu == null) { return false; } this.pc = cu.ProjectContent; this.caretLine = caretLine; this.caretColumn = caretColumn; this.callingClass = GetCallingClass(pc); callingMember = ResolveCurrentMember(callingClass); if (callingMember == null) { if (cu != parseInfo.CompilationUnit) { IClass olderClass = GetCallingClass(parseInfo.CompilationUnit.ProjectContent); if (olderClass != null && callingClass == null) { this.callingClass = olderClass; } callingMember = ResolveCurrentMember(olderClass); } } if (callingMember != null) { if (caretLine > callingMember.BodyRegion.EndLine) { this.caretLine = callingMember.BodyRegion.EndLine; this.caretColumn = callingMember.BodyRegion.EndColumn - 1; } else if (caretLine == callingMember.BodyRegion.EndLine && caretColumn >= callingMember.BodyRegion.EndColumn) { this.caretColumn = callingMember.BodyRegion.EndColumn - 1; } } return true; }
public CodeFunction(IMethod method, IDocumentLoader documentLoader) : base(method) { this.method = method; this.documentLoader = documentLoader; }
static void TryAddExtension(LanguageProperties language, ArrayList res, IMethodOrProperty ext, IReturnType resolvedType) { // accept only extension methods if (!ext.IsExtensionMethod) return; // don't add extension if method with that name already exists // but allow overloading extension methods foreach (IMember member in res) { IMethodOrProperty p = member as IMethodOrProperty; if (p != null && p.IsExtensionMethod) continue; if (language.NameComparer.Equals(member.Name, ext.Name)) { return; } } // now add the extension method if it fits the type if (MemberLookupHelper.ConversionExists(resolvedType, ext.Parameters[0].ReturnType)) { IMethod method = ext as IMethod; if (method != null && method.TypeParameters.Count > 0) { IReturnType[] typeArguments = new IReturnType[method.TypeParameters.Count]; MemberLookupHelper.InferTypeArgument(method.Parameters[0].ReturnType, resolvedType, typeArguments); for (int i = 0; i < typeArguments.Length; i++) { if (typeArguments[i] != null) { ext = (IMethod)ext.Clone(); ext.ReturnType = ConstructedReturnType.TranslateType(ext.ReturnType, typeArguments, true); for (int j = 0; j < ext.Parameters.Count; ++j) { ext.Parameters[j].ReturnType = ConstructedReturnType.TranslateType(ext.Parameters[j].ReturnType, typeArguments, true); } break; } } } res.Add(ext); } }
public ResolveResult ResolveInternal(Expression expr, ExpressionContext context) { TypeVisitor typeVisitor = new TypeVisitor(this); IReturnType type; if (expr is PrimitiveExpression) { if (((PrimitiveExpression)expr).Value is int) { return(new IntegerLiteralResolveResult(callingClass, callingMember, projectContent.SystemTypes.Int32)); } } else if (expr is InvocationExpression) { IMethodOrProperty method = typeVisitor.GetMethod(expr as InvocationExpression); if (method != null) { return(CreateMemberResolveResult(method)); } else { // InvocationExpression can also be a delegate/event call ResolveResult invocationTarget = ResolveInternal((expr as InvocationExpression).TargetObject, ExpressionContext.Default); if (invocationTarget == null) { return(null); } type = invocationTarget.ResolvedType; if (type == null) { return(null); } IClass c = type.GetUnderlyingClass(); if (c == null || c.ClassType != ClassType.Delegate) { return(null); } // We don't want to show "System.EventHandler.Invoke" in the tooltip // of "EventCall(this, EventArgs.Empty)", we just show the event/delegate for now // but for DelegateCall(params).* completion, we use the delegate's // return type instead of the delegate type itself method = c.Methods.Find(delegate(IMethod innerMethod) { return(innerMethod.Name == "Invoke"); }); if (method != null) { invocationTarget.ResolvedType = method.ReturnType; } return(invocationTarget); } } else if (expr is IndexerExpression) { return(CreateMemberResolveResult(typeVisitor.GetIndexer(expr as IndexerExpression))); } else if (expr is FieldReferenceExpression) { FieldReferenceExpression fieldReferenceExpression = (FieldReferenceExpression)expr; if (fieldReferenceExpression.FieldName == null || fieldReferenceExpression.FieldName.Length == 0) { // NRefactory creates this "dummy" fieldReferenceExpression when it should // parse a primitive type name (int, short; Integer, Decimal) if (fieldReferenceExpression.TargetObject is TypeReferenceExpression) { type = TypeVisitor.CreateReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference, this); if (type != null) { return(new TypeResolveResult(callingClass, callingMember, type)); } } } type = fieldReferenceExpression.TargetObject.AcceptVisitor(typeVisitor, null) as IReturnType; if (type != null) { ResolveResult result = ResolveMemberReferenceExpression(type, fieldReferenceExpression); if (result != null) { return(result); } } } else if (expr is IdentifierExpression) { ResolveResult result = ResolveIdentifier(((IdentifierExpression)expr).Identifier, context); if (result != null) { return(result); } } else if (expr is TypeReferenceExpression) { type = TypeVisitor.CreateReturnType(((TypeReferenceExpression)expr).TypeReference, this); if (type != null) { if (type is TypeVisitor.NamespaceReturnType) { return(new NamespaceResolveResult(callingClass, callingMember, type.FullyQualifiedName)); } IClass c = type.GetUnderlyingClass(); if (c != null) { return(new TypeResolveResult(callingClass, callingMember, type, c)); } } return(null); } type = expr.AcceptVisitor(typeVisitor, null) as IReturnType; if (type == null || type.FullyQualifiedName == "") { return(null); } if (expr is ObjectCreateExpression) { List <IMethod> constructors = new List <IMethod>(); foreach (IMethod m in type.GetMethods()) { if (m.IsConstructor && !m.IsStatic) { constructors.Add(m); } } if (constructors.Count == 0) { // Class has no constructors -> create default constructor IClass c = type.GetUnderlyingClass(); if (c != null) { return(CreateMemberResolveResult(Constructor.CreateDefault(c))); } } IReturnType[] typeParameters = null; if (type.IsConstructedReturnType) { typeParameters = new IReturnType[type.CastToConstructedReturnType().TypeArguments.Count]; type.CastToConstructedReturnType().TypeArguments.CopyTo(typeParameters, 0); } ResolveResult rr = CreateMemberResolveResult(typeVisitor.FindOverload(constructors, typeParameters, ((ObjectCreateExpression)expr).Parameters, null)); if (rr != null) { rr.ResolvedType = type; } return(rr); } return(new ResolveResult(callingClass, callingMember, type)); }
internal static void AddParameters(AST.ParameterDeclarationCollection parameters, IList <IParameter> output, IMethodOrProperty method, IClass c) { if (c == null) { throw new ArgumentNullException("c"); } DefaultParameter p = null; foreach (AST.ParameterDeclaration par in parameters) { p = new DefaultParameter(par.Name, CreateReturnType(par.Type, c, method as IMethod, c.Region.BeginLine + 1, 1, c.ProjectContent), new DomRegion(par.LexicalInfo.Line, par.LexicalInfo.Column)); if (par.IsByRef) { p.Modifiers |= ParameterModifiers.Ref; } output.Add(p); } if (parameters.HasParamArray) { p.Modifiers |= ParameterModifiers.Params; } }