public CombinedMethodResolveResult(MemberResolveResult baseResolveResult, MethodResolveResult methodResolveResult) { BaseResolveResult = baseResolveResult; MethodResolveResult = methodResolveResult; CallingType = baseResolveResult.CallingType; CallingMember = baseResolveResult.CallingMember; StaticResolve = baseResolveResult.StaticResolve; ResolvedMember = baseResolveResult.ResolvedMember; ResolvedExpression = baseResolveResult.ResolvedExpression; }
public NRefactoryParameterDataProvider (TextEditorData editor, NRefactoryResolver resolver, MethodResolveResult resolveResult) { this.staticResolve = resolveResult.StaticResolve; bool includeProtected = true; HashSet<string> alreadyAdded = new HashSet<string> (); foreach (IMethod method in resolveResult.Methods) { if (method.IsConstructor) continue; string str = ambience.GetString (method, OutputFlags.IncludeParameters | OutputFlags.GeneralizeGenerics | OutputFlags.IncludeGenerics); if (alreadyAdded.Contains (str)) continue; alreadyAdded.Add (str); if (method.IsAccessibleFrom (resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected)) methods.Add (method); } methods.Sort (MethodComparer); }
public CombinedMethodResolveResult (MemberResolveResult baseResolveResult, MethodResolveResult methodResolveResult) { BaseResolveResult = baseResolveResult; MethodResolveResult = methodResolveResult; CallingType = baseResolveResult.CallingType; CallingMember = baseResolveResult.CallingMember; StaticResolve = baseResolveResult.StaticResolve; ResolvedMember = baseResolveResult.ResolvedMember; ResolvedExpression = baseResolveResult.ResolvedExpression; }
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data) { if (invocationExpression == null) return null; if (invocationDictionary.ContainsKey (invocationExpression)) return invocationDictionary[invocationExpression]; // add support for undocumented __makeref and __reftype keywords if (invocationExpression.TargetObject is IdentifierExpression) { IdentifierExpression idExpr = invocationExpression.TargetObject as IdentifierExpression; if (idExpr.Identifier == "__makeref") return CreateResult ("System.TypedReference"); if (idExpr.Identifier == "__reftype") return CreateResult ("System.Type"); } ResolveResult targetResult = Resolve (invocationExpression.TargetObject); if (targetResult is CombinedMethodResolveResult) targetResult = ((CombinedMethodResolveResult)targetResult).MethodResolveResult; targetResult.StaticResolve = false; // invocation result is never static if (this.resolver.CallingType != null) { if (targetResult is ThisResolveResult) { targetResult = new MethodResolveResult (this.resolver.CallingType.Methods.Where (method => method.IsConstructor)); ((MethodResolveResult)targetResult).Type = this.resolver.CallingType; targetResult.CallingType = resolver.CallingType; targetResult.CallingMember = resolver.CallingMember; } else if (targetResult is BaseResolveResult) { System.Collections.IEnumerable baseConstructors = null; IType firstBaseType = null; foreach (IReturnType bT in this.resolver.CallingType.BaseTypes) { IType resolvedBaseType = resolver.SearchType (bT); if (firstBaseType == null && resolvedBaseType.ClassType != MonoDevelop.Projects.Dom.ClassType.Interface) firstBaseType = resolvedBaseType; foreach (IType baseType in resolver.Dom.GetInheritanceTree (resolvedBaseType)) { if (baseType.ClassType == MonoDevelop.Projects.Dom.ClassType.Interface) break; baseConstructors = baseType.Methods.Where (method => method.IsConstructor); goto bailOut; } } bailOut: if (baseConstructors == null) { if (firstBaseType != null) { // if there is a real base type without a .ctor a default .ctor for this type is generated. DomMethod constructedConstructor; constructedConstructor = new DomMethod (); constructedConstructor.Name = ".ctor"; constructedConstructor.MethodModifier = MethodModifier.IsConstructor; constructedConstructor.DeclaringType = firstBaseType; constructedConstructor.Modifiers = MonoDevelop.Projects.Dom.Modifiers.Public; baseConstructors = new IMethod[] { constructedConstructor }; } else { baseConstructors = resolver.SearchType (DomReturnType.Object).SearchMember (".ctor", true); } } targetResult = new MethodResolveResult (baseConstructors); ((MethodResolveResult)targetResult).Type = this.resolver.CallingType; targetResult.CallingType = resolver.CallingType; targetResult.CallingMember = resolver.CallingMember; } } MethodResolveResult methodResult = targetResult as MethodResolveResult; if (methodResult != null) { methodResult.GetsInvoked = true; // Console.WriteLine ("--------------------"); // Console.WriteLine ("i:" + methodResult.ResolvedType); /* foreach (var arg in methodResult.GenericArguments) { methodResult.AddGenericArgument (arg); }*/ foreach (Expression arg in invocationExpression.Arguments) { var type = GetTypeSafe (arg); methodResult.AddArgument (type); } //Console.WriteLine ("--------------------"); methodResult.ResolveExtensionMethods (); // Console.WriteLine ("i2:" + methodResult.ResolvedType); /* MemberReferenceExpression mre = invocationExpression.TargetObject as MemberReferenceExpression; if (mre != null) { foreach (TypeReference typeReference in mre.TypeArguments) { methodResult.AddGenericArgument (new DomReturnType (String.IsNullOrEmpty (typeReference.SystemType) ? typeReference.Type : typeReference.SystemType)); } }*/ // return CreateResult (methodResult.Methods [0].ReturnType); } invocationDictionary[invocationExpression] = targetResult; return targetResult; }
ResolveResult ResolveMemberReference (ResolveResult result, MemberReferenceExpression memberReferenceExpression) { IType type = resolver.Dom.GetType (result.ResolvedType); if (type == null) return null; //Console.WriteLine ("Resolve member: " + memberReferenceExpression.MemberName + " on " + type); List<IMember> member = new List<IMember> (); List<IType> accessibleExtTypes = DomType.GetAccessibleExtensionTypes (resolver.Dom, resolver.Unit); // Inheritance of extension methods is handled in DomType foreach (IMethod method in type.GetExtensionMethods (accessibleExtTypes)) { if (method.Name == memberReferenceExpression.MemberName) { member.Add (method); } } bool includeProtected = true; foreach (IType curType in resolver.Dom.GetInheritanceTree (type)) { if (curType.ClassType == MonoDevelop.Projects.Dom.ClassType.Interface && type.ClassType != MonoDevelop.Projects.Dom.ClassType.Interface) continue; if (curType.IsAccessibleFrom (resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected)) { foreach (IMember foundMember in curType.SearchMember (memberReferenceExpression.MemberName, true)) { if (foundMember.IsExplicitDeclaration) continue; if (result is BaseResolveResult && foundMember.IsAbstract) continue; member.Add (foundMember); } } } if (member.Count > 0) { if (member[0] is IMethod) { bool isStatic = result.StaticResolve; List<IMember> nonMethodMembers = new List<IMember> (); List<string> errors = new List<string> (); int typeParameterCount = 0; if (memberReferenceExpression.TypeArguments != null) typeParameterCount = memberReferenceExpression.TypeArguments.Count; for (int i = 0; i < member.Count; i++) { IMethod method = member[i] as IMethod; if (method == null) nonMethodMembers.Add (member[i]); if (!member[i].IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, includeProtected)) errors.Add ( MonoDevelop.Core.GettextCatalog.GetString ("'{0}' is inaccessible due to its protection level.", ambience.GetString (method, OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics))); if (method != null && !method.IsFinalizer && (method.IsExtension || method.WasExtended)/* && method.IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, true)*/) { continue; } if ((member[i].IsStatic ^ isStatic) || /* !member[i].IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, includeProtected) || */ (method != null && (method.IsFinalizer || typeParameterCount > 0 && method.TypeParameters.Count != typeParameterCount))) { member.RemoveAt (i); i--; } } if (member.Count == 0) return null; result = new MethodResolveResult (member); ((MethodResolveResult)result).Type = type; result.CallingType = resolver.CallingType; result.CallingMember = resolver.CallingMember; result.ResolveErrors.AddRange (errors); //result.StaticResolve = isStatic; //result.UnresolvedType = result.ResolvedType = member[0].ReturnType; foreach (TypeReference typeReference in memberReferenceExpression.TypeArguments) { ((MethodResolveResult)result).AddGenericArgument (resolver.ResolveType (typeReference.ConvertToReturnType ())); } ((MethodResolveResult)result).ResolveExtensionMethods (); if (nonMethodMembers.Count > 0) { MemberResolveResult baseResult = (MemberResolveResult) CreateResult (nonMethodMembers[0].DeclaringType.CompilationUnit, nonMethodMembers[0].ReturnType); baseResult.ResolvedMember = nonMethodMembers[0]; return new CombinedMethodResolveResult (baseResult, (MethodResolveResult)result); } //System.Console.WriteLine(result + "/" + result.ResolvedType); return result; } if (member[0] is IType) { result = CreateResult (member[0].FullName); result.StaticResolve = true; } else { result = CreateResult (member[0].DeclaringType.CompilationUnit, member[0].ReturnType); ((MemberResolveResult)result).ResolvedMember = member[0]; } if (!member[0].IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, includeProtected)) result.ResolveErrors.Add (string.Format (MonoDevelop.Core.GettextCatalog.GetString ("'{0}' is inaccessible due to it's protection level."), ambience.GetString (member[0], OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics))); return result; } return new UnresolvedMemberResolveResult (result, memberReferenceExpression.MemberName) { CallingType = resolver.CallingType, CallingMember = resolver.CallingMember }; }
public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) { if (identifierExpression.TypeArguments != null && identifierExpression.TypeArguments.Count > 0) { if (resolver.CallingType != null) { foreach (var type in resolver.Dom.GetInheritanceTree (resolver.CallingType)) { IMethod possibleMethod = type.Methods.Where (m => m.Name == identifierExpression.Identifier && m.TypeParameters.Count == identifierExpression.TypeArguments.Count && m.IsAccessibleFrom (resolver.Dom, resolver.CallingType, resolver.CallingMember, true)).FirstOrDefault (); if (possibleMethod != null) { MethodResolveResult methodResolveResult = new MethodResolveResult (possibleMethod); methodResolveResult.CallingType = resolver.CallingType; methodResolveResult.CallingMember = resolver.CallingMember; identifierExpression.TypeArguments.ForEach (arg => methodResolveResult.AddGenericArgument (resolver.ResolveType (arg.ConvertToReturnType ()))); methodResolveResult.ResolveExtensionMethods (); return methodResolveResult; } } } TypeReference reference = new TypeReference (identifierExpression.Identifier); reference.GenericTypes.AddRange (identifierExpression.TypeArguments); ResolveResult result = CreateResult (reference); result.StaticResolve = true; return result; } // Console.WriteLine ("visit id: " + identifierExpression.Identifier); var res = resolver.ResolveIdentifier (this, identifierExpression.Identifier.TrimEnd ('.')); // Console.WriteLine ("result: " + res); return res; }
public ResolveResult ResolveIdentifier(ResolveVisitor visitor, string identifier) { ResolveResult result = null; if (resultTable.TryGetValue (identifier, out result)) return result; resultTable[identifier] = result; foreach (KeyValuePair<string, List<LocalLookupVariable>> pair in this.lookupTableVisitor.Variables) { if (identifier == pair.Key) { LocalLookupVariable var = null; // Console.WriteLine ("--- RP:" + this.resolvePosition + "/" + pair.Value.Count); foreach (LocalLookupVariable v2 in pair.Value) { DomLocation varStartPos = new DomLocation (lookupVariableLine + v2.StartPos.Line, v2.StartPos.Column - 1); DomLocation varEndPos = new DomLocation (lookupVariableLine + v2.EndPos.Line, v2.EndPos.Column - 1); // Console.WriteLine (v2.Name + ":" + varStartPos + " <> " + varEndPos); if (varStartPos > this.resolvePosition || (!v2.EndPos.IsEmpty && varEndPos < this.resolvePosition)) continue; var = v2; } // Console.WriteLine ("var:" + var); if (var == null) continue; IReturnType varType = null; IReturnType varTypeUnresolved = null; if (var.IsQueryContinuation) { QueryExpression query = var.Initializer as QueryExpression; QueryExpressionGroupClause grouBy = query.SelectOrGroupClause as QueryExpressionGroupClause; DomLocation old = resolvePosition; try { resolvePosition = new DomLocation (lookupVariableLine + grouBy.Projection.StartLocation.Line, grouBy.Projection.StartLocation.Column); ResolveResult initializerResolve = visitor.Resolve (grouBy.Projection); ResolveResult groupByResolve = visitor.Resolve (grouBy.GroupBy); DomReturnType resolved = new DomReturnType (dom.GetType ("System.Linq.IGrouping", new IReturnType [] { DomType.GetComponentType (dom, initializerResolve.ResolvedType), groupByResolve.ResolvedType})); varTypeUnresolved = varType = resolved; } finally { resolvePosition = old; } } else if ((var.TypeRef == null || var.TypeRef.Type == "var" || var.TypeRef.IsNull)) { if (var.ParentLambdaExpression != null) { ResolveResult lambdaResolve = ResolveLambda (visitor, var.ParentLambdaExpression); if (lambdaResolve != null) { varType = lambdaResolve.ResolvedType; varTypeUnresolved = lambdaResolve.UnresolvedType; } else { varType = varTypeUnresolved = DomReturnType.Void; } } if (var.Initializer != null) { ResolveResult initializerResolve = visitor.Resolve (var.Initializer); // Console.WriteLine ("initializer : "+ var.Initializer + " result:" + initializerResolve); varType = var.IsLoopVariable ? DomType.GetComponentType (dom, initializerResolve.ResolvedType) : initializerResolve.ResolvedType; varTypeUnresolved = var.IsLoopVariable ? DomType.GetComponentType (dom, initializerResolve.UnresolvedType) : initializerResolve.UnresolvedType; // Console.WriteLine ("resolved type:" + initializerResolve.ResolvedType + " is loop : " + var.IsLoopVariable); // Console.WriteLine (varType); // Console.WriteLine ("----------"); } } else { varTypeUnresolved = varType = ConvertTypeReference (var.TypeRef); } // Console.WriteLine ("-----"); // Console.WriteLine (varType); varType = ResolveType (varType); result = new LocalVariableResolveResult ( new LocalVariable (CallingMember, identifier, varType, new DomRegion (lookupVariableLine + var.StartPos.Line - 1, var.StartPos.Column - 1, lookupVariableLine + var.StartPos.Line - 1, var.EndPos.Column - 1)), var.IsLoopVariable); result.ResolvedType = varType; result.UnresolvedType = varTypeUnresolved; goto end; } } if (this.callingMember != null) { // special handling of property or field return types, they can have the same name as the return type // ex.: MyType MyType { get; set; } Type1 Type1; if ((callingMember is IProperty || callingMember is IField) && identifier == callingMember.Name) { int pos = editor.GetPositionFromLineColumn (resolvePosition.Line, resolvePosition.Column); while (pos < editor.TextLength && !Char.IsWhiteSpace (editor.GetCharAt (pos))) pos++; while (pos < editor.TextLength && Char.IsWhiteSpace (editor.GetCharAt (pos))) pos++; StringBuilder memberName = new StringBuilder (); while (pos < editor.TextLength && (Char.IsLetterOrDigit (editor.GetCharAt (pos)) || editor.GetCharAt (pos) == '_') ) { memberName.Append (editor.GetCharAt (pos)); pos++; } //Console.WriteLine ("id: '" + identifier + "' : '" + memberName.ToString () +"'" + (memberName.ToString () == identifier)); if (memberName.ToString () == identifier) { result = visitor.CreateResult (callingMember.ReturnType); goto end; } } if (identifier == "value" && this.callingMember is IProperty) { result = new MemberResolveResult (this.callingMember); result.UnresolvedType = ((IProperty)this.callingMember).ReturnType; result.ResolvedType = ResolveType (((IProperty)this.callingMember).ReturnType); goto end; } if (this.callingMember is IMethod || this.callingMember is IProperty) { ReadOnlyCollection<IParameter> prms = this.callingMember is IMethod ? ((IMethod)this.callingMember).Parameters : ((IProperty)this.callingMember).Parameters; if (prms != null) { foreach (IParameter para in prms) { if (para.Name == identifier) { result = new ParameterResolveResult (para); result.UnresolvedType = para.ReturnType; result.ResolvedType = ResolveType (para.ReturnType); goto end; } } } } } IType searchedType = dom.SearchType (new SearchTypeRequest (unit, this.CallingType, identifier)); if (this.callingType != null && dom != null) { List<IMember> members = new List <IMember> (); foreach (IType type in dom.GetInheritanceTree (callingType)) { members.AddRange (type.SearchMember (identifier, true)); } bool includeProtected = true; // filter members if (this.CallingMember != null) { for (int i = 0; i < members.Count; i++) { if (this.CallingMember.IsStatic && !members[i].IsStatic || !members[i].IsAccessibleFrom (dom, callingType, this.CallingMember, includeProtected)) { members.RemoveAt (i); i--; continue; } } } if (members.Count > 0) { if (members[0] is IMethod) { result = new MethodResolveResult (members); if (CallingMember != null) result.StaticResolve = CallingMember.IsStatic; } else if (members[0] is IType) { result = new MemberResolveResult (null, true); result.UnresolvedType = result.ResolvedType = new DomReturnType ((IType)members[0]); goto end; } else { result = new MemberResolveResult (members[0]); } result.UnresolvedType = members[0].ReturnType; result.ResolvedType = ResolveType (members[0].ReturnType); if (members[0] is IProperty && searchedType != null && result.ResolvedType.FullName == searchedType.FullName) { result = new AggregatedResolveResult (result, new MemberResolveResult (null, true) { UnresolvedType = new DomReturnType (searchedType), ResolvedType = new DomReturnType (searchedType) }); } goto end; } } if (searchedType != null) { result = new MemberResolveResult (null, true); result.UnresolvedType = result.ResolvedType = new DomReturnType (searchedType); goto end; } if (dom.NamespaceExists (identifier, true)) { result = new NamespaceResolveResult (identifier); goto end; } if (unit != null && unit.Usings != null) { foreach (IUsing u in unit.Usings) { if (u.IsFromNamespace && u.Region.Contains (resolvePosition)) { foreach (string ns in u.Namespaces) { if (dom.NamespaceExists (ns + "." + identifier, true)) { result = new NamespaceResolveResult (ns + "." + identifier); goto end; } } } foreach (KeyValuePair<string, IReturnType> alias in u.Aliases) { if (alias.Key == identifier || alias.Key + ".?" == identifier) { result = new NamespaceResolveResult (alias.Value.FullName); goto end; } } } } end: if (result != null) { result.CallingType = CallingType; result.CallingMember = CallingMember; } resultTable[identifier] = result; return result; }