IEnumerable<ICompletionData> CreateCompletionData (TextLocation location, ResolveResult resolveResult, AstNode resolvedNode, CppResolver state) { if (resolveResult == null /*|| resolveResult.IsError*/) return null; if (resolveResult is NamespaceResolveResult) { var nr = (NamespaceResolveResult)resolveResult; var namespaceContents = new CompletionDataWrapper (this); foreach (var cl in nr.Namespace.Types) { namespaceContents.AddType (cl, cl.Name); } foreach (var ns in nr.Namespace.ChildNamespaces) { namespaceContents.AddNamespace (ns.Name); } return namespaceContents.Result; } IType type = resolveResult.Type; var typeDef = resolveResult.Type.GetDefinition (); var result = new CompletionDataWrapper (this); bool includeStaticMembers = false; if (resolveResult is LocalResolveResult) { if (resolvedNode is IdentifierExpression) { var mrr = (LocalResolveResult)resolveResult; includeStaticMembers = mrr.Variable.Name == mrr.Type.Name; } } if (resolveResult is TypeResolveResult && type.Kind == TypeKind.Enum) { foreach (var field in type.GetFields ()) { result.AddMember (field); } foreach (var m in type.GetMethods ()) { if (m.Name == "TryParse") result.AddMember (m); } return result.Result; } if (resolveResult is MemberResolveResult && resolvedNode is IdentifierExpression) { var mrr = (MemberResolveResult)resolveResult; includeStaticMembers = mrr.Member.Name == mrr.Type.Name; // ADD Aliases var scope = CSharpParsedFile.GetUsingScope (location).Resolve (Compilation); for (var n = scope; n != null; n = n.Parent) { foreach (var pair in n.UsingAliases) { if (pair.Key == mrr.Member.Name) { foreach (var r in CreateCompletionData (location, pair.Value, resolvedNode, state)) { if (r is IEntityCompletionData && ((IEntityCompletionData)r).Entity is IMember) { result.AddMember ((IMember)((IEntityCompletionData)r).Entity); } else { result.Add (r); } } } } } } if (resolveResult is TypeResolveResult && (resolvedNode is IdentifierExpression || resolvedNode is MemberReferenceExpression)) { includeStaticMembers = true; } // Console.WriteLine ("type:" + type +"/"+type.GetType ()); // Console.WriteLine ("current:" + ctx.CurrentTypeDefinition); // Console.WriteLine ("IS PROT ALLOWED:" + isProtectedAllowed + " static: "+ includeStaticMembers); // Console.WriteLine (resolveResult); // Console.WriteLine ("node:" + resolvedNode); // Console.WriteLine (currentMember != null ? currentMember.IsStatic : "currentMember == null"); if (resolvedNode.Annotation<ObjectCreateExpression> () == null) { //tags the created expression as part of an object create expression. var lookup = new MemberLookup (ctx.CurrentTypeDefinition, Compilation.MainAssembly); bool isProtectedAllowed = resolveResult is ThisResolveResult ? true : lookup.IsProtectedAccessAllowed (type); var filteredList = new List<IMember> (); foreach (var member in type.GetMembers ()) { // Console.WriteLine ("member:" + member + member.IsShadowing); if (!lookup.IsAccessible (member, isProtectedAllowed)) { // Console.WriteLine ("skip access: " + member.FullName); continue; } if (resolvedNode is BaseReferenceExpression && member.IsAbstract) continue; bool memberIsStatic = member.IsStatic; if (!includeStaticMembers && memberIsStatic && !(resolveResult is TypeResolveResult)) { // Console.WriteLine ("skip static member: " + member.FullName); continue; } var field = member as IField; if (field != null) memberIsStatic |= field.IsConst; if (!memberIsStatic && (resolveResult is TypeResolveResult)) { continue; } if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") continue; if (member.EntityType == EntityType.Operator) continue; if (member.IsShadowing) filteredList.RemoveAll (m => m.Name == member.Name); filteredList.Add (member); } foreach (var member in filteredList) { // Console.WriteLine ("add : "+ member.FullName + " --- " + member.IsStatic); result.AddMember (member); } } if (resolveResult is TypeResolveResult || includeStaticMembers) { foreach (var nested in type.GetNestedTypes ()) { result.AddType (nested, nested.Name); } } else { foreach (var meths in state.GetExtensionMethods (type)) { foreach (var m in meths) { result.AddMember (m); } } } // IEnumerable<object> objects = resolveResult.CreateResolveResult (dom, resolver != null ? resolver.CallingMember : null); // CompletionDataCollector col = new CompletionDataCollector (this, dom, result, Document.CompilationUnit, resolver != null ? resolver.CallingType : null, location); // col.HideExtensionParameter = !resolveResult.StaticResolve; // col.NamePrefix = expressionResult.Expression; // bool showOnlyTypes = expressionResult.Contexts.Any (ctx => ctx == ExpressionContext.InheritableType || ctx == ExpressionContext.Constraints); // if (objects != null) { // foreach (object obj in objects) { // if (expressionResult.ExpressionContext != null && expressionResult.ExpressionContext.FilterEntry (obj)) // continue; // if (expressionResult.ExpressionContext == ExpressionContext.NamespaceNameExcepted && !(obj is Namespace)) // continue; // if (showOnlyTypes && !(obj is IType)) // continue; // CompletionData data = col.Add (obj); // if (data != null && expressionResult.ExpressionContext == ExpressionContext.Attribute && data.CompletionText != null && data.CompletionText.EndsWith ("Attribute")) { // string newText = data.CompletionText.Substring (0, data.CompletionText.Length - "Attribute".Length); // data.SetText (newText); // } // } // } return result.Result; }
ResolveResult LookInCurrentType(string identifier, IList<IType> typeArguments, SimpleNameLookupMode lookupMode, bool parameterizeResultType) { int k = typeArguments.Count; MemberLookup lookup; if (lookupMode == SimpleNameLookupMode.BaseTypeReference && this.CurrentTypeDefinition != null) { // When looking up a base type reference, treat us as being outside the current type definition // for accessibility purposes. // This avoids a stack overflow when referencing a protected class nested inside the base class // of a parent class. (NameLookupTests.InnerClassInheritingFromProtectedBaseInnerClassShouldNotCauseStackOverflow) lookup = new MemberLookup(this.CurrentTypeDefinition.DeclaringTypeDefinition, this.Compilation.MainAssembly, false); } else { lookup = CreateMemberLookup(); } // look in current type definitions for (ITypeDefinition t = this.CurrentTypeDefinition; t != null; t = t.DeclaringTypeDefinition) { if (k == 0) { // Look for type parameter with that name var typeParameters = t.TypeParameters; // Look at all type parameters, including those copied from outer classes, // so that we can fetch the version with the correct owner. for (int i = 0; i < typeParameters.Count; i++) { if (typeParameters[i].Name == identifier) return new TypeResolveResult(typeParameters[i]); } } if (lookupMode == SimpleNameLookupMode.BaseTypeReference && t == this.CurrentTypeDefinition) { // don't look in current type when resolving a base type reference continue; } ResolveResult r; if (lookupMode == SimpleNameLookupMode.Expression || lookupMode == SimpleNameLookupMode.InvocationTarget) { var targetResolveResult = (t == this.CurrentTypeDefinition ? ResolveThisReference() : new TypeResolveResult(t)); r = lookup.Lookup(targetResolveResult, identifier, typeArguments, lookupMode == SimpleNameLookupMode.InvocationTarget); } else { r = lookup.LookupType(t, identifier, typeArguments, parameterizeResultType); } if (!(r is UnknownMemberResolveResult)) // but do return AmbiguousMemberResolveResult return r; } return null; }
IEnumerable<ICompletionData> CreateTypeCompletionData (IType hintType, AstType hintTypeAst) { var wrapper = new CompletionDataWrapper (this); var state = GetState (); Predicate<IType> pred = null; if (hintType != null) { if (hintType.Kind != TypeKind.Unknown) { var lookup = new MemberLookup (ctx.CurrentTypeDefinition, Compilation.MainAssembly); pred = t => { // check if type is in inheritance tree. if (hintType.GetDefinition () != null && !t.GetDefinition ().IsDerivedFrom (hintType.GetDefinition ())) return false; // check for valid constructors if (t.GetConstructors ().Count () == 0) return true; bool isProtectedAllowed = currentType != null ? currentType.Resolve (ctx).GetDefinition ().IsDerivedFrom (t.GetDefinition ()) : false; return t.GetConstructors ().Any (m => lookup.IsAccessible (m, isProtectedAllowed)); }; DefaultCompletionString = GetShortType (hintType, GetState ()); wrapper.AddType (hintType, DefaultCompletionString); } else { DefaultCompletionString = hintTypeAst.ToString (); wrapper.AddType (hintType, DefaultCompletionString); } } AddTypesAndNamespaces (wrapper, state, null, pred, m => false); AddKeywords (wrapper, primitiveTypesKeywords.Where (k => k != "void")); CloseOnSquareBrackets = true; AutoCompleteEmptyMatch = true; return wrapper.Result; }