protected override void AddVirtuals (List<IMember> alreadyInserted, CompletionDataWrapper col, string modifiers, IType curType, int declarationBegin) { base.AddVirtuals (alreadyInserted, col, modifiers, curType, declarationBegin); foreach (var member in GetProtocolMembers (curType)) { if (alreadyInserted.Contains (member)) continue; if (BaseExportCodeGenerator.IsImplemented (curType, member)) continue; alreadyInserted.Add (member); var data = new ProtocolCompletionData (this, declarationBegin, member); col.Add (data); } }
void AddContextCompletion(CompletionDataWrapper wrapper, CSharpResolver state, AstNode node, CompilationUnit unit) { if (state != null && !(node is AstType)) { foreach (var variable in state.LocalVariables) { if (variable.Region.IsInside(location.Line, location.Column - 1)) { continue; } wrapper.AddVariable(variable); } } if (currentMember is IUnresolvedParameterizedMember && !(node is AstType)) { var param = (IParameterizedMember)currentMember.CreateResolved(ctx); foreach (var p in param.Parameters) { wrapper.AddVariable(p); } } if (currentMember is IUnresolvedMethod) { var method = (IUnresolvedMethod)currentMember; foreach (var p in method.TypeParameters) { wrapper.AddTypeParameter(p); } } Func<IType, IType> typePred = null; if (IsAttributeContext(node)) { var attribute = Compilation.FindType(KnownTypeCode.Attribute); typePred = t => { return t.GetAllBaseTypeDefinitions().Any(bt => bt.Equals(attribute)) ? t : null; }; } AddTypesAndNamespaces(wrapper, state, node, typePred); wrapper.Result.Add(factory.CreateLiteralCompletionData("global")); if (!(node is AstType)) { if (currentMember != null || node is Expression) { AddKeywords(wrapper, statementStartKeywords); AddKeywords(wrapper, expressionLevelKeywords); if (node is TypeDeclaration) AddKeywords(wrapper, typeLevelKeywords); } else if (currentType != null) { AddKeywords(wrapper, typeLevelKeywords); } else { AddKeywords(wrapper, globalLevelKeywords); } var prop = currentMember as IUnresolvedProperty; if (prop != null && prop.Setter != null && prop.Setter.Region.IsInside(location)) { wrapper.AddCustom("value"); } if (currentMember is IUnresolvedEvent) { wrapper.AddCustom("value"); } if (IsInSwitchContext(node)) { wrapper.AddCustom("case"); } } else { if (((AstType)node).Parent is ParameterDeclaration) { AddKeywords(wrapper, parameterTypePredecessorKeywords); } } AddKeywords(wrapper, primitiveTypesKeywords); if (currentMember != null) { wrapper.AddCustom("var"); } wrapper.Result.AddRange(factory.CreateCodeTemplateCompletionData()); if (node != null && node.Role == Roles.Argument) { var resolved = ResolveExpression(node.Parent, unit); var invokeResult = resolved != null ? resolved.Item1 as CSharpInvocationResolveResult : null; if (invokeResult != null) { int argNum = 0; foreach (var arg in node.Parent.Children.Where (c => c.Role == Roles.Argument)) { if (arg == node) { break; } argNum++; } var param = argNum < invokeResult.Member.Parameters.Count ? invokeResult.Member.Parameters [argNum] : null; if (param != null && param.Type.Kind == TypeKind.Enum) { AddEnumMembers(wrapper, param.Type, state); } } } if (node is Expression) { var astResolver = new CSharpAstResolver(state, unit, CSharpParsedFile); foreach (var type in CreateFieldAction.GetValidTypes(astResolver, (Expression)node)) { if (type.Kind == TypeKind.Enum) { AddEnumMembers(wrapper, type, state); } else if (type.Kind == TypeKind.Delegate) { AddDelegateHandlers(wrapper, type, true, true); AutoSelect = false; AutoCompleteEmptyMatch = false; } } } // Add 'this' keyword for first parameter (extension method case) if (node != null && node.Parent is ParameterDeclaration && node.Parent.PrevSibling != null && node.Parent.PrevSibling.Role == Roles.LPar) { wrapper.AddCustom("this"); } }
IEnumerable<ICompletionData> CreateCaseCompletionData(TextLocation location) { var unit = ParseStub("a: break;"); if (unit == null) { return null; } var s = unit.GetNodeAt<SwitchStatement>(location); if (s == null) { return null; } var offset = document.GetOffset(s.Expression.StartLocation); var expr = GetExpressionAt(offset); if (expr == null) { return null; } var resolveResult = ResolveExpression(expr); if (resolveResult == null || resolveResult.Result.Type.Kind != TypeKind.Enum) { return null; } var wrapper = new CompletionDataWrapper(this); AddEnumMembers(wrapper, resolveResult.Result.Type, resolveResult.Resolver); AutoCompleteEmptyMatch = false; return wrapper.Result; }
IEnumerable<ICompletionData> CreateCompletionData(TextLocation location, ResolveResult resolveResult, AstNode resolvedNode, CSharpResolver state, Func<IType, IType> typePred = null) { if (resolveResult == null /* || resolveResult.IsError*/) { return null; } var lookup = new MemberLookup( ctx.CurrentTypeDefinition, Compilation.MainAssembly ); if (resolveResult is NamespaceResolveResult) { var nr = (NamespaceResolveResult)resolveResult; var namespaceContents = new CompletionDataWrapper(this); foreach (var cl in nr.Namespace.Types) { if (!lookup.IsAccessible(cl, false)) continue; IType addType = typePred != null ? typePred(cl) : cl; if (addType != null) namespaceContents.AddType(addType, false); } foreach (var ns in nr.Namespace.ChildNamespaces) { namespaceContents.AddNamespace(lookup, ns); } return namespaceContents.Result; } IType type = resolveResult.Type; if (type.Namespace == "System" && type.Name == "Void") return null; if (resolvedNode.Parent is PointerReferenceExpression && (type is PointerType)) { resolveResult = new OperatorResolveResult(((PointerType)type).ElementType, System.Linq.Expressions.ExpressionType.Extension, resolveResult); } //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 ()) { if (!lookup.IsAccessible(field, false)) continue; result.AddMember(field); } return result.Result; } bool isProtectedAllowed = resolveResult is ThisResolveResult ? true : lookup.IsProtectedAccessAllowed(type); bool skipNonStaticMembers = (resolveResult is TypeResolveResult); if (resolveResult is MemberResolveResult && resolvedNode is IdentifierExpression) { var mrr = (MemberResolveResult)resolveResult; includeStaticMembers = mrr.Member.Name == mrr.Type.Name; TypeResolveResult trr; if (state.IsVariableReferenceWithSameType( resolveResult, ((IdentifierExpression)resolvedNode).Identifier, out trr )) { if (currentMember != null && mrr.Member.IsStatic ^ currentMember.IsStatic) { skipNonStaticMembers = true; if (trr.Type.Kind == TypeKind.Enum) { foreach (var field in trr.Type.GetFields ()) { if (lookup.IsAccessible(field, false)) result.AddMember(field); } return result.Result; } } } // ADD Aliases var scope = ctx.CurrentUsingScope; 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 filteredList = new List<IMember>(); foreach (var member in type.GetMembers ()) { filteredList.Add(member); } foreach (var member in filteredList) { // Console.WriteLine ("add:" + member + "/" + member.IsStatic); result.AddMember(member); }*/ foreach (var member in lookup.GetAccessibleMembers (resolveResult)) { if (member.SymbolKind == SymbolKind.Indexer || member.SymbolKind == SymbolKind.Operator || member.SymbolKind == SymbolKind.Constructor || member.SymbolKind == SymbolKind.Destructor) { continue; } if (resolvedNode is BaseReferenceExpression && member.IsAbstract) { continue; } if (member is IType) { if (resolveResult is TypeResolveResult || includeStaticMembers) { if (!lookup.IsAccessible(member, isProtectedAllowed)) continue; result.AddType((IType)member, false); 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 && skipNonStaticMembers) { continue; } if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") { continue; } if (member.SymbolKind == SymbolKind.Operator) { continue; } if (member is IMember) { result.AddMember((IMember)member); } } } if (!(resolveResult is TypeResolveResult || includeStaticMembers)) { foreach (var meths in state.GetExtensionMethods (type)) { foreach (var m in meths) { if (!lookup.IsAccessible(m, isProtectedAllowed)) continue; result.AddMember(new ReducedExtensionMethod(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; }
IEnumerable<ICompletionData> CreateParameterCompletion(MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, SyntaxTree unit, int parameter, bool controlSpace) { var result = new CompletionDataWrapper(this); var addedEnums = new HashSet<string>(); var addedDelegates = new HashSet<string>(); foreach (var method in resolveResult.Methods) { CreateParameterForInvocation(result, method, state, parameter, addedEnums, addedDelegates); } foreach (var methods in resolveResult.GetEligibleExtensionMethods (true)) { foreach (var method in methods) { if (resolveResult.Methods.Contains(method)) continue; CreateParameterForInvocation(result, new ReducedExtensionMethod(method), state, parameter, addedEnums, addedDelegates); } } foreach (var method in resolveResult.Methods) { if (parameter < method.Parameters.Count && method.Parameters [parameter].Type.Kind == TypeKind.Delegate) { AutoSelect = false; AutoCompleteEmptyMatch = false; } foreach (var p in method.Parameters) { result.AddNamedParameterVariable(p); } } if (!controlSpace) { if (addedEnums.Count + addedDelegates.Count == 0) { return Enumerable.Empty<ICompletionData>(); } AutoCompleteEmptyMatch = false; AutoSelect = false; } AddContextCompletion(result, state, invocation); // resolver.AddAccessibleCodeCompletionData (ExpressionContext.MethodBody, cdc); // if (addedDelegates.Count > 0) { // foreach (var data in result.Result) { // if (data is MemberCompletionData) // ((MemberCompletionData)data).IsDelegateExpected = true; // } // } return result.Result; }
IEnumerable<ICompletionData> CreateTypeAndNamespaceCompletionData(TextLocation location, ResolveResult resolveResult, AstNode resolvedNode, CSharpResolver state) { if (resolveResult == null || resolveResult.IsError) { return null; } var exprParent = resolvedNode.GetParent<Expression>(); var unit = exprParent != null ? exprParent.GetParent<SyntaxTree>() : null; var astResolver = unit != null ? CompletionContextProvider.GetResolver(state, unit) : null; IType hintType = exprParent != null && astResolver != null ? TypeGuessing.GetValidTypes(astResolver, exprParent).FirstOrDefault() : null; var result = new CompletionDataWrapper(this); var lookup = new MemberLookup( ctx.CurrentTypeDefinition, Compilation.MainAssembly ); if (resolveResult is NamespaceResolveResult) { var nr = (NamespaceResolveResult)resolveResult; if (!(resolvedNode.Parent is UsingDeclaration || resolvedNode.Parent != null && resolvedNode.Parent.Parent is UsingDeclaration)) { foreach (var cl in nr.Namespace.Types) { if (hintType != null && hintType.Kind != TypeKind.Array && cl.Kind == TypeKind.Interface) { continue; } if (!lookup.IsAccessible(cl, false)) continue; result.AddType(cl, false, IsAttributeContext(resolvedNode)); } } foreach (var ns in nr.Namespace.ChildNamespaces) { result.AddNamespace(lookup, ns); } } else if (resolveResult is TypeResolveResult) { var type = resolveResult.Type; foreach (var nested in type.GetNestedTypes ()) { if (hintType != null && hintType.Kind != TypeKind.Array && nested.Kind == TypeKind.Interface) { continue; } var def = nested.GetDefinition(); if (def != null && !lookup.IsAccessible(def, false)) continue; result.AddType(nested, false); } } return result.Result; }
void AddKeywords(CompletionDataWrapper wrapper, IEnumerable<string> keywords) { if (!IncludeKeywordsInCompletionList) return; foreach (string keyword in keywords) { if (wrapper.Result.Any(data => data.DisplayText == keyword)) continue; wrapper.AddCustom(keyword); } }
IEnumerable<ICompletionData> GetPartialCompletionData(ITypeDefinition type, string modifiers) { var wrapper = new CompletionDataWrapper(this); int declarationBegin = offset; int j = declarationBegin; for (int i = 0; i < 3; i++) { switch (GetPreviousToken(ref j, true)) { case "public": case "protected": case "private": case "internal": case "sealed": case "override": case "partial": case "async": declarationBegin = j; break; case "static": return null; // don't add override completion for static members } } var methods = new List<IUnresolvedMethod>(); foreach (var part in type.Parts) { foreach (var method in part.Methods) { if (method.BodyRegion.IsEmpty) { if (GetImplementation(type, method) != null) { continue; } methods.Add(method); } } } foreach (var method in methods) { wrapper.Add(factory.CreateNewPartialCompletionData( declarationBegin, method.DeclaringTypeDefinition, method ) ); } return wrapper.Result; }
IEnumerable<ICompletionData> HandleCatchClauseType(ExpressionResult identifierStart) { Func<IType, IType> typePred = delegate (IType type) { if (type.GetAllBaseTypes().Any(t => t.ReflectionName == "System.Exception")) return type; return null; }; if (identifierStart.Node.Parent is CatchClause) { var wrapper = new CompletionDataWrapper(this); AddTypesAndNamespaces( wrapper, GetState(), identifierStart.Node, typePred, m => false ); return wrapper.Result; } var resolveResult = ResolveExpression(identifierStart); return CreateCompletionData( location, resolveResult.Result, identifierStart.Node, resolveResult.Resolver, typePred ); }
IEnumerable<ICompletionData> HandleObjectInitializer(CompilationUnit unit, AstNode n) { var p = n.Parent; while (p != null && !(p is ObjectCreateExpression)) { p = p.Parent; } var parent = (ArrayInitializerExpression)n.Parent; if (parent.IsSingleElement) parent = (ArrayInitializerExpression)parent.Parent; if (p != null) { var contextList = new CompletionDataWrapper(this); var initializerResult = ResolveExpression(p, unit); if (initializerResult != null && initializerResult.Item1.Type.Kind != TypeKind.Unknown) { // check 3 cases: // 1) New initalizer { xpr // 2) Object initializer { prop = val1, field = val2, xpr // 3) Array initializer { new Foo (), a, xpr // in case 1 all object/array initializer options should be given - in the others not. AstNode prev = null; if (parent.Elements.Count > 1) { prev = parent.Elements.First(); if (prev is ArrayInitializerExpression && ((ArrayInitializerExpression)prev).IsSingleElement) prev = ((ArrayInitializerExpression)prev).Elements.FirstOrDefault(); } if (prev != null && !(prev is NamedExpression)) { AddContextCompletion(contextList, GetState(), n, unit); // case 3) return contextList.Result; } foreach (var m in initializerResult.Item1.Type.GetMembers (m => m.IsPublic && (m.EntityType == EntityType.Property || m.EntityType == EntityType.Field))) { contextList.AddMember(m); } if (prev != null && (prev is NamedExpression)) { // case 2) return contextList.Result; } // case 1) // check if the object is a list, if not only provide object initalizers var list = typeof(System.Collections.IList).ToTypeReference().Resolve(Compilation); if (initializerResult.Item1.Type.Kind != TypeKind.Array && list != null) { var def = initializerResult.Item1.Type.GetDefinition(); if (def != null && !def.IsDerivedFrom(list.GetDefinition())) return contextList.Result; } AddContextCompletion(contextList, GetState(), n, unit); return contextList.Result; } } return null; }
void AddEnumMembers(CompletionDataWrapper completionList, IType resolvedType, CSharpResolver state) { if (resolvedType.Kind != TypeKind.Enum) { return; } string typeString = GetShortType(resolvedType, state); if (typeString.Contains(".")) { completionList.AddType(resolvedType, typeString); } foreach (var field in resolvedType.GetFields ()) { if (field.IsConst || field.IsStatic) { completionList.Result.Add(factory.CreateEntityCompletionData( field, typeString + "." + field.Name ) ); } } DefaultCompletionString = typeString; }
IEnumerable<ICompletionData> CreateParameterCompletion(MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, CompilationUnit unit, int parameter, bool controlSpace) { var result = new CompletionDataWrapper(this); var addedEnums = new HashSet<string>(); var addedDelegates = new HashSet<string>(); foreach (var method in resolveResult.Methods) { if (method.Parameters.Count <= parameter) { continue; } var resolvedType = method.Parameters [parameter].Type; if (resolvedType.Kind == TypeKind.Enum) { if (addedEnums.Contains(resolvedType.ReflectionName)) { continue; } addedEnums.Add(resolvedType.ReflectionName); AddEnumMembers(result, resolvedType, state); } else if (resolvedType.Kind == TypeKind.Delegate) { if (addedDelegates.Contains(resolvedType.ReflectionName)) continue; string parameterDefinition = AddDelegateHandlers(result, resolvedType); string varName = "Handle" + method.Parameters [parameter].Type.Name + method.Parameters [parameter].Name; result.Result.Add( factory.CreateEventCreationCompletionData( varName, resolvedType, null, parameterDefinition, currentMember, currentType) ); } } if (!controlSpace) { if (addedEnums.Count + addedDelegates.Count == 0) { return Enumerable.Empty<ICompletionData>(); } AutoCompleteEmptyMatch = false; AutoSelect = false; } AddContextCompletion(result, state, invocation, unit); // resolver.AddAccessibleCodeCompletionData (ExpressionContext.MethodBody, cdc); // if (addedDelegates.Count > 0) { // foreach (var data in result.Result) { // if (data is MemberCompletionData) // ((MemberCompletionData)data).IsDelegateExpected = true; // } // } return result.Result; }
IEnumerable<ICompletionData> CreateTypeAndNamespaceCompletionData(TextLocation location, ResolveResult resolveResult, AstNode resolvedNode, CSharpResolver state) { if (resolveResult == null || resolveResult.IsError) { return null; } var exprParent = resolvedNode.GetParent<Expression>(); var unit = exprParent != null ? exprParent.GetParent<CompilationUnit>() : null; var astResolver = unit != null ? new CSharpAstResolver( state, unit, CSharpParsedFile ) : null; IType hintType = exprParent != null && astResolver != null ? CreateFieldAction.GetValidTypes(astResolver, exprParent) .FirstOrDefault() : null; var result = new CompletionDataWrapper(this); if (resolveResult is NamespaceResolveResult) { var nr = (NamespaceResolveResult)resolveResult; if (!(resolvedNode.Parent is UsingDeclaration || resolvedNode.Parent != null && resolvedNode.Parent.Parent is UsingDeclaration)) { foreach (var cl in nr.Namespace.Types) { string name = cl.Name; if (hintType != null && hintType.Kind != TypeKind.Array && cl.Kind == TypeKind.Interface) { continue; } if (IsAttributeContext(resolvedNode) && name.EndsWith("Attribute") && name.Length > "Attribute".Length) { name = name.Substring(0, name.Length - "Attribute".Length); } result.AddType(cl, name); } } foreach (var ns in nr.Namespace.ChildNamespaces) { result.AddNamespace(ns.Name); } } else if (resolveResult is TypeResolveResult) { var type = resolveResult.Type; foreach (var nested in type.GetNestedTypes ()) { if (hintType != null && hintType.Kind != TypeKind.Array && nested.Kind == TypeKind.Interface) { continue; } result.AddType(nested, nested.Name); } } return result.Result; }
string AddDelegateHandlers(CompletionDataWrapper completionList, IType delegateType, bool addSemicolon = true, bool addDefault = true) { IMethod delegateMethod = delegateType.GetDelegateInvokeMethod(); var thisLineIndent = GetLineIndent(location.Line); string delegateEndString = EolMarker + thisLineIndent + "}" + (addSemicolon ? ";" : ""); //bool containsDelegateData = completionList.Result.Any(d => d.DisplayText.StartsWith("delegate(")); if (addDefault) { var oldDelegate = completionList.Result.FirstOrDefault(cd => cd.DisplayText == "delegate"); if (oldDelegate != null) completionList.Result.Remove(oldDelegate); completionList.AddCustom( "delegate", "Creates anonymous delegate.", "delegate {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); } var sb = new StringBuilder("("); var sbWithoutTypes = new StringBuilder("("); for (int k = 0; k < delegateMethod.Parameters.Count; k++) { if (k > 0) { sb.Append(", "); sbWithoutTypes.Append(", "); } var parameterType = delegateMethod.Parameters [k].Type; sb.Append(GetShortType(parameterType, GetState())); sb.Append(" "); sb.Append(delegateMethod.Parameters [k].Name); sbWithoutTypes.Append(delegateMethod.Parameters [k].Name); } sb.Append(")"); sbWithoutTypes.Append(")"); completionList.AddCustom( "delegate" + sb, "Creates anonymous delegate.", "delegate" + sb + " {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); if (!completionList.Result.Any(data => data.DisplayText == sbWithoutTypes.ToString())) { completionList.AddCustom( sbWithoutTypes.ToString(), "Creates lambda expression.", sbWithoutTypes + " => |" + (addSemicolon ? ";" : "") ); } /* TODO:Make factory method out of it. // It's needed to temporarly disable inserting auto matching bracket because the anonymous delegates are selectable with '(' // otherwise we would end up with () => ) if (!containsDelegateData) { var savedValue = MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket; MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket = false; completionList.Result.CompletionListClosed += delegate { MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket = savedValue; }; }*/ return sb.ToString(); }
void AddTypesAndNamespaces(CompletionDataWrapper wrapper, CSharpResolver state, AstNode node, Func<IType, IType> typePred = null, Predicate<IMember> memberPred = null, Action<ICompletionData, IType> callback = null) { var lookup = new MemberLookup( ctx.CurrentTypeDefinition, Compilation.MainAssembly ); if (currentType != null) { for (var ct = currentType; ct != null; ct = ct.DeclaringTypeDefinition) { foreach (var nestedType in ct.NestedTypes) { string name = nestedType.Name; if (IsAttributeContext(node) && name.EndsWith("Attribute") && name.Length > "Attribute".Length) { name = name.Substring(0, name.Length - "Attribute".Length); } if (typePred == null) { wrapper.AddType(nestedType, name); continue; } var type = typePred(nestedType.Resolve(ctx)); if (type != null) { var a2 = wrapper.AddType(type, name); if (a2 != null && callback != null) { callback(a2, type); } } continue; } } if (this.currentMember != null && !(node is AstType)) { var def = ctx.CurrentTypeDefinition ?? Compilation.MainAssembly.GetTypeDefinition(currentType); if (def != null) { bool isProtectedAllowed = true; foreach (var member in def.GetMembers ()) { if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") { continue; } if (member.EntityType == EntityType.Operator) { continue; } if (member.IsExplicitInterfaceImplementation) { continue; } if (!lookup.IsAccessible(member, isProtectedAllowed)) { continue; } if (memberPred == null || memberPred(member)) { wrapper.AddMember(member); } } var declaring = def.DeclaringTypeDefinition; while (declaring != null) { foreach (var member in declaring.GetMembers (m => m.IsStatic)) { if (memberPred == null || memberPred(member)) { wrapper.AddMember(member); } } declaring = declaring.DeclaringTypeDefinition; } } } foreach (var p in currentType.TypeParameters) { wrapper.AddTypeParameter(p); } } var scope = CSharpParsedFile.GetUsingScope(location).Resolve(Compilation); for (var n = scope; n != null; n = n.Parent) { foreach (var pair in n.UsingAliases) { wrapper.AddNamespace(pair.Key); } foreach (var u in n.Usings) { foreach (var type in u.Types) { if (!lookup.IsAccessible(type, false)) continue; IType addType = typePred != null ? typePred(type) : type; if (addType != null) { string name = type.Name; if (IsAttributeContext(node) && name.EndsWith("Attribute") && name.Length > "Attribute".Length) { name = name.Substring(0, name.Length - "Attribute".Length); } var a = wrapper.AddType(addType, name); if (a != null && callback != null) { callback(a, type); } } } } foreach (var type in n.Namespace.Types) { if (!lookup.IsAccessible(type, false)) continue; IType addType = typePred != null ? typePred(type) : type; if (addType != null) { var a2 = wrapper.AddType(addType, addType.Name); if (a2 != null && callback != null) { callback(a2, type); } } } foreach (var curNs in n.Namespace.ChildNamespaces) { wrapper.AddNamespace(curNs.Name); } } }
IEnumerable<ICompletionData> CreateConstructorCompletionData(IType hintType) { var wrapper = new CompletionDataWrapper(this); var state = GetState(); Func<IType, IType> pred = null; Action<ICompletionData, IType> typeCallback = null; var inferredTypesCategory = new Category("Inferred Types", null); var derivedTypesCategory = new Category("Derived Types", null); if (hintType != null) { if (hintType.Kind != TypeKind.Unknown) { var lookup = new MemberLookup( ctx.CurrentTypeDefinition, Compilation.MainAssembly ); typeCallback = (data, t) => { //check if type is in inheritance tree. if (hintType.GetDefinition() != null && t.GetDefinition() != null && t.GetDefinition().IsDerivedFrom(hintType.GetDefinition())) { data.CompletionCategory = derivedTypesCategory; } }; pred = t => { if (t.Kind == TypeKind.Interface && hintType.Kind != TypeKind.Array) { return null; } // check for valid constructors if (t.GetConstructors().Count() > 0) { bool isProtectedAllowed = currentType != null ? currentType.Resolve(ctx).GetDefinition().IsDerivedFrom(t.GetDefinition()) : false; if (!t.GetConstructors().Any(m => lookup.IsAccessible(m, isProtectedAllowed))) { return null; } } // check derived types var typeDef = t.GetDefinition(); var hintDef = hintType.GetDefinition(); if (typeDef != null && hintDef != null && typeDef.IsDerivedFrom(hintDef)) { var newType = wrapper.AddType(t, true); if (newType != null) { newType.CompletionCategory = inferredTypesCategory; } } // check type inference var typeInference = new TypeInference(Compilation); typeInference.Algorithm = TypeInferenceAlgorithm.ImprovedReturnAllResults; var inferedType = typeInference.FindTypeInBounds(new [] { t }, new [] { hintType }); if (inferedType != SpecialType.UnknownType) { var newType = wrapper.AddType(inferedType, true); if (newType != null) { newType.CompletionCategory = inferredTypesCategory; } return null; } return t; }; if (!(hintType.Kind == TypeKind.Interface && hintType.Kind != TypeKind.Array)) { var hint = wrapper.AddType(hintType, true); if (hint != null) { DefaultCompletionString = hint.DisplayText; hint.CompletionCategory = derivedTypesCategory; } } if (hintType is ParameterizedType && hintType.TypeParameterCount == 1 && hintType.FullName == "System.Collections.Generic.IEnumerable") { var arg = ((ParameterizedType)hintType).TypeArguments.FirstOrDefault(); if (arg.Kind != TypeKind.TypeParameter) { var array = new ArrayType(ctx.Compilation, arg, 1); wrapper.AddType(array, true); } } } else { var hint = wrapper.AddType(hintType, true); if (hint != null) { DefaultCompletionString = hint.DisplayText; hint.CompletionCategory = derivedTypesCategory; } } } AddTypesAndNamespaces(wrapper, state, null, pred, m => false, typeCallback, true); if (hintType == null || hintType == SpecialType.UnknownType) { AddKeywords(wrapper, primitiveTypesKeywords.Where(k => k != "void")); } CloseOnSquareBrackets = true; AutoCompleteEmptyMatch = true; AutoCompleteEmptyMatchOnCurlyBracket = false; return wrapper.Result; }
IEnumerable<ICompletionData> GetOverrideCompletionData(IUnresolvedTypeDefinition type, string modifiers) { var wrapper = new CompletionDataWrapper(this); var alreadyInserted = new List<IMember>(); //bool addedVirtuals = false; int declarationBegin = offset; int j = declarationBegin; for (int i = 0; i < 3; i++) { switch (GetPreviousToken(ref j, true)) { case "public": case "protected": case "private": case "internal": case "sealed": case "override": case "partial": case "async": declarationBegin = j; break; case "static": return null; // don't add override completion for static members } } AddVirtuals( alreadyInserted, wrapper, modifiers, type.Resolve(ctx), declarationBegin ); return wrapper.Result; }
IEnumerable<ICompletionData> HandleEnumContext() { var syntaxTree = ParseStub("a", false); if (syntaxTree == null) { return null; } var curType = syntaxTree.GetNodeAt<TypeDeclaration>(location); if (curType == null || curType.ClassType != ClassType.Enum) { syntaxTree = ParseStub("a {}", false); var node = syntaxTree.GetNodeAt<AstType>(location); if (node != null) { var wrapper = new CompletionDataWrapper(this); AddKeywords(wrapper, validEnumBaseTypes); return wrapper.Result; } } var member = syntaxTree.GetNodeAt<EnumMemberDeclaration>(location); if (member != null && member.NameToken.EndLocation < location) { if (currentMember == null && currentType != null) { foreach (var a in currentType.Members) if (a.Region.Begin < location && (currentMember == null || a.Region.Begin > currentMember.Region.Begin)) currentMember = a; } bool isComplete = false; return DefaultControlSpaceItems(ref isComplete); } var attribute = syntaxTree.GetNodeAt<Attribute>(location); if (attribute != null) { var contextList = new CompletionDataWrapper(this); var astResolver = CompletionContextProvider.GetResolver(GetState(), syntaxTree); var csResolver = astResolver.GetResolverStateBefore(attribute); AddContextCompletion( contextList, csResolver, attribute ); return contextList.Result; } return null; }
protected virtual void AddVirtuals(List<IMember> alreadyInserted, CompletionDataWrapper col, string modifiers, IType curType, int declarationBegin) { if (curType == null) { return; } foreach (var m in curType.GetMembers ().Reverse ()) { if (curType.Kind != TypeKind.Interface && !m.IsOverridable) { continue; } // filter out the "Finalize" methods, because finalizers should be done with destructors. if (m is IMethod && m.Name == "Finalize") { continue; } var data = factory.CreateNewOverrideCompletionData( declarationBegin, currentType, m ); // check if the member is already implemented bool foundMember = curType.GetMembers().Any(cm => SignatureComparer.Ordinal.Equals( cm, m ) && cm.DeclaringTypeDefinition == curType.GetDefinition() ); if (foundMember) { continue; } if (alreadyInserted.Any(cm => SignatureComparer.Ordinal.Equals(cm, m))) continue; alreadyInserted.Add(m); data.CompletionCategory = col.GetCompletionCategory(m.DeclaringTypeDefinition); col.Add(data); } }
IEnumerable<ICompletionData> HandleAccessorContext() { var unit = ParseStub("get; }", false); var node = unit.GetNodeAt(location, cn => !(cn is CSharpTokenNode)); if (node is Accessor) { node = node.Parent; } var contextList = new CompletionDataWrapper(this); if (node is PropertyDeclaration || node is IndexerDeclaration) { if (IncludeKeywordsInCompletionList) { contextList.AddCustom("get"); contextList.AddCustom("set"); AddKeywords(contextList, accessorModifierKeywords); } } else if (node is CustomEventDeclaration) { if (IncludeKeywordsInCompletionList) { contextList.AddCustom("add"); contextList.AddCustom("remove"); } } else { return null; } return contextList.Result; }
string AddDelegateHandlers(CompletionDataWrapper completionList, IType delegateType, bool addSemicolon = true, bool addDefault = true, string optDelegateName = null) { IMethod delegateMethod = delegateType.GetDelegateInvokeMethod(); PossibleDelegates.Add(delegateMethod); var thisLineIndent = GetLineIndent(location.Line); string delegateEndString = EolMarker + thisLineIndent + "}" + (addSemicolon ? ";" : ""); //bool containsDelegateData = completionList.Result.Any(d => d.DisplayText.StartsWith("delegate(")); if (addDefault && !completionList.AnonymousDelegateAdded) { completionList.AnonymousDelegateAdded = true; var oldDelegate = completionList.Result.FirstOrDefault(cd => cd.DisplayText == "delegate"); if (oldDelegate != null) completionList.Result.Remove(oldDelegate); completionList.AddCustom( "delegate", "Creates anonymous delegate.", "delegate {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); if (LanguageVersion.Major >= 5) { completionList.AddCustom( "async delegate", "Creates anonymous async delegate.", "async delegate {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); } } var sb = new StringBuilder("("); var sbWithoutTypes = new StringBuilder("("); var state = GetState(); var builder = new TypeSystemAstBuilder(state); for (int k = 0; k < delegateMethod.Parameters.Count; k++) { if (k > 0) { sb.Append(", "); sbWithoutTypes.Append(", "); } var convertedParameter = builder.ConvertParameter(delegateMethod.Parameters [k]); if (convertedParameter.ParameterModifier == ParameterModifier.Params) convertedParameter.ParameterModifier = ParameterModifier.None; sb.Append(convertedParameter.ToString(FormattingPolicy)); sbWithoutTypes.Append(delegateMethod.Parameters [k].Name); } sb.Append(")"); sbWithoutTypes.Append(")"); var signature = sb.ToString(); if (!completionList.HasAnonymousDelegateAdded(signature)) { completionList.AddAnonymousDelegateAdded(signature); completionList.AddCustom( "delegate" + signature, "Creates anonymous delegate.", "delegate" + signature + " {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); if (LanguageVersion.Major >= 5) { completionList.AddCustom( "async delegate" + signature, "Creates anonymous async delegate.", "async delegate" + signature + " {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); } if (!completionList.Result.Any(data => data.DisplayText == sb.ToString())) { completionList.AddCustom( signature, "Creates typed lambda expression.", signature + " => |" + (addSemicolon ? ";" : "") ); if (LanguageVersion.Major >= 5) { completionList.AddCustom( "async " + signature, "Creates typed async lambda expression.", "async " + signature + " => |" + (addSemicolon ? ";" : "") ); } if (!delegateMethod.Parameters.Any(p => p.IsOut || p.IsRef) && !completionList.Result.Any(data => data.DisplayText == sbWithoutTypes.ToString())) { completionList.AddCustom( sbWithoutTypes.ToString(), "Creates lambda expression.", sbWithoutTypes + " => |" + (addSemicolon ? ";" : "") ); if (LanguageVersion.Major >= 5) { completionList.AddCustom( "async " + sbWithoutTypes, "Creates async lambda expression.", "async " + sbWithoutTypes + " => |" + (addSemicolon ? ";" : "") ); } } } } string varName = "Handle" + delegateType.Name + optDelegateName; completionList.Add(factory.CreateEventCreationCompletionData(varName, delegateType, null, signature, currentMember, currentType)); /* TODO:Make factory method out of it. // It's needed to temporarly disable inserting auto matching bracket because the anonymous delegates are selectable with '(' // otherwise we would end up with () => ) if (!containsDelegateData) { var savedValue = MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket; MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket = false; completionList.Result.CompletionListClosed += delegate { MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket = savedValue; }; }*/ return sb.ToString(); }
IEnumerable<ICompletionData> DefaultControlSpaceItems(ref bool isComplete, ExpressionResult xp = null, bool controlSpace = true) { var wrapper = new CompletionDataWrapper(this); if (offset >= document.TextLength) { offset = document.TextLength - 1; } while (offset > 1 && char.IsWhiteSpace(document.GetCharAt(offset))) { offset--; } location = document.GetLocation(offset); if (xp == null) { xp = GetExpressionAtCursor(); } AstNode node; SyntaxTree unit; ExpressionResolveResult rr; if (xp != null) { node = xp.Node; rr = ResolveExpression(node); unit = xp.Unit; } else { unit = ParseStub("foo", false); node = unit.GetNodeAt( location.Line, location.Column + 2, n => n is Expression || n is AstType || n is NamespaceDeclaration || n is Attribute ); rr = ResolveExpression(node); } var ifvisitor = new IfVisitor(location, CompletionContextProvider); unit.AcceptVisitor(ifvisitor); ifvisitor.End(); if (!ifvisitor.IsValid) return null; // namespace name case var ns = node as NamespaceDeclaration; if (ns != null) { var last = ns.NamespaceName; if (last != null && location < last.EndLocation) return null; } if (node is Identifier && node.Parent is ForeachStatement) { var foreachStmt = (ForeachStatement)node.Parent; foreach (var possibleName in GenerateNameProposals (foreachStmt.VariableType)) { if (possibleName.Length > 0) { wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString())); } } AutoSelect = false; AutoCompleteEmptyMatch = false; isComplete = true; return wrapper.Result; } if (node is Identifier && node.Parent is ParameterDeclaration) { if (!controlSpace) { return null; } // Try Parameter name case var param = node.Parent as ParameterDeclaration; if (param != null) { foreach (var possibleName in GenerateNameProposals (param.Type)) { if (possibleName.Length > 0) { wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString())); } } AutoSelect = false; AutoCompleteEmptyMatch = false; isComplete = true; return wrapper.Result; } } var pDecl = node as ParameterDeclaration; if (pDecl != null && pDecl.Parent is LambdaExpression) { return null; } /* if (Unit != null && (node == null || node is TypeDeclaration)) { var constructor = Unit.GetNodeAt<ConstructorDeclaration>( location.Line, location.Column - 3 ); if (constructor != null && !constructor.ColonToken.IsNull && constructor.Initializer.IsNull) { wrapper.AddCustom("this"); wrapper.AddCustom("base"); return wrapper.Result; } }*/ var initializer = node != null ? node.Parent as ArrayInitializerExpression : null; if (initializer != null) { var result = HandleObjectInitializer(unit, initializer); if (result != null) return result; } CSharpResolver csResolver = null; if (rr != null) { csResolver = rr.Resolver; } if (csResolver == null) { if (node != null) { csResolver = GetState(); //var astResolver = new CSharpAstResolver (csResolver, node, xp != null ? xp.Item1 : CSharpUnresolvedFile); try { //csResolver = astResolver.GetResolverStateBefore (node); Console.WriteLine(csResolver.LocalVariables.Count()); } catch (Exception e) { Console.WriteLine("E!!!" + e); } } else { csResolver = GetState(); } } if (node is Attribute) { // add attribute properties. var astResolver = CompletionContextProvider.GetResolver(csResolver, unit); var resolved = astResolver.Resolve(node); AddAttributeProperties(wrapper, resolved); } if (node == null) { // try lambda unit = ParseStub("foo) => {}", true); var pd = unit.GetNodeAt<ParameterDeclaration>( location.Line, location.Column ); if (pd != null) { var astResolver = unit != null ? CompletionContextProvider.GetResolver(GetState(), unit) : null; var parameterType = astResolver.Resolve(pd.Type); // Type <name> is always a name context -> return null if (parameterType != null && !parameterType.IsError) return null; } } AddContextCompletion(wrapper, csResolver, node); return wrapper.Result; }
void CreateParameterForInvocation(CompletionDataWrapper result, IMethod method, CSharpResolver state, int parameter, HashSet<string> addedEnums, HashSet<string> addedDelegates) { if (method.Parameters.Count <= parameter) { return; } var resolvedType = method.Parameters [parameter].Type; if (resolvedType.Kind == TypeKind.Enum) { if (addedEnums.Contains(resolvedType.ReflectionName)) { return; } addedEnums.Add(resolvedType.ReflectionName); AddEnumMembers(result, resolvedType, state); return; } if (resolvedType.Kind == TypeKind.Delegate) { if (addedDelegates.Contains(resolvedType.ReflectionName)) return; AddDelegateHandlers(result, resolvedType, false, true, method.Parameters [parameter].Name); } }
static void AddAttributeProperties(CompletionDataWrapper wrapper, ResolveResult resolved) { if (resolved == null || resolved.Type.Kind == TypeKind.Unknown) return; foreach (var property in resolved.Type.GetProperties (p => p.Accessibility == Accessibility.Public)) { var data = wrapper.AddMember(property); if (data != null) data.DisplayFlags |= DisplayFlags.NamedArgument; } foreach (var field in resolved.Type.GetFields (p => p.Accessibility == Accessibility.Public)) { var data = wrapper.AddMember(field); if (data != null) data.DisplayFlags |= DisplayFlags.NamedArgument; } foreach (var constructor in resolved.Type.GetConstructors (p => p.Accessibility == Accessibility.Public)) { foreach (var p in constructor.Parameters) { wrapper.AddNamedParameterVariable(p); } } }
void AddEnumMembers(CompletionDataWrapper completionList, IType resolvedType, CSharpResolver state) { if (resolvedType.Kind != TypeKind.Enum) { return; } var type = completionList.AddEnumMembers(resolvedType, state); if (type != null) DefaultCompletionString = type.DisplayText; }
void AddContextCompletion(CompletionDataWrapper wrapper, CSharpResolver state, AstNode node) { int i = offset - 1; var isInGlobalDelegate = node == null && state.CurrentTypeDefinition == null && GetPreviousToken(ref i, true) == "delegate"; if (state != null && !(node is AstType)) { foreach (var variable in state.LocalVariables) { if (variable.Region.IsInside(location.Line, location.Column - 1)) { continue; } wrapper.AddVariable(variable); } } if (state.CurrentMember is IParameterizedMember && !(node is AstType)) { var param = (IParameterizedMember)state.CurrentMember; foreach (var p in param.Parameters) { wrapper.AddVariable(p); } } if (state.CurrentMember is IMethod) { var method = (IMethod)state.CurrentMember; foreach (var p in method.TypeParameters) { wrapper.AddTypeParameter(p); } } Func<IType, IType> typePred = null; if (IsAttributeContext(node)) { var attribute = Compilation.FindType(KnownTypeCode.Attribute); typePred = t => t.GetAllBaseTypeDefinitions().Any(bt => bt.Equals(attribute)) ? t : null; } if (node != null && node.Role == Roles.BaseType) { typePred = t => { var def = t.GetDefinition(); if (def != null && t.Kind != TypeKind.Interface && (def.IsSealed || def.IsStatic)) return null; return t; }; } if (node != null && !(node is NamespaceDeclaration) || state.CurrentTypeDefinition != null || isInGlobalDelegate) { AddTypesAndNamespaces(wrapper, state, node, typePred); wrapper.Result.Add(factory.CreateLiteralCompletionData("global")); } if (!(node is AstType)) { if (currentMember != null || node is Expression) { AddKeywords(wrapper, statementStartKeywords); if (LanguageVersion.Major >= 5) AddKeywords(wrapper, new [] { "await" }); AddKeywords(wrapper, expressionLevelKeywords); if (node == null || node is TypeDeclaration) AddKeywords(wrapper, typeLevelKeywords); } else if (currentType != null) { AddKeywords(wrapper, typeLevelKeywords); } else { if (!isInGlobalDelegate && !(node is Attribute)) AddKeywords(wrapper, globalLevelKeywords); } var prop = currentMember as IUnresolvedProperty; if (prop != null && prop.Setter != null && prop.Setter.Region.IsInside(location)) { wrapper.AddCustom("value"); } if (currentMember is IUnresolvedEvent) { wrapper.AddCustom("value"); } if (IsInSwitchContext(node)) { if (IncludeKeywordsInCompletionList) wrapper.AddCustom("case"); } } else { if (((AstType)node).Parent is ParameterDeclaration) { AddKeywords(wrapper, parameterTypePredecessorKeywords); } } if (node != null || state.CurrentTypeDefinition != null || isInGlobalDelegate) AddKeywords(wrapper, primitiveTypesKeywords); if (currentMember != null && (node is IdentifierExpression || node is SimpleType) && (node.Parent is ExpressionStatement || node.Parent is ForeachStatement || node.Parent is UsingStatement)) { if (IncludeKeywordsInCompletionList) { wrapper.AddCustom("var"); wrapper.AddCustom("dynamic"); } } wrapper.Result.AddRange(factory.CreateCodeTemplateCompletionData()); if (node != null && node.Role == Roles.Argument) { var resolved = ResolveExpression(node.Parent); var invokeResult = resolved != null ? resolved.Result as CSharpInvocationResolveResult : null; if (invokeResult != null) { int argNum = 0; foreach (var arg in node.Parent.Children.Where (c => c.Role == Roles.Argument)) { if (arg == node) { break; } argNum++; } var param = argNum < invokeResult.Member.Parameters.Count ? invokeResult.Member.Parameters [argNum] : null; if (param != null && param.Type.Kind == TypeKind.Enum) { AddEnumMembers(wrapper, param.Type, state); } } } if (node is Expression) { var root = node; while (root.Parent != null) root = root.Parent; var astResolver = CompletionContextProvider.GetResolver(state, root); foreach (var type in TypeGuessing.GetValidTypes(astResolver, (Expression)node)) { if (type.Kind == TypeKind.Enum) { AddEnumMembers(wrapper, type, state); } else if (type.Kind == TypeKind.Delegate) { AddDelegateHandlers(wrapper, type, false, true); AutoSelect = false; AutoCompleteEmptyMatch = false; } } } // Add 'this' keyword for first parameter (extension method case) if (node != null && node.Parent is ParameterDeclaration && node.Parent.PrevSibling != null && node.Parent.PrevSibling.Role == Roles.LPar && IncludeKeywordsInCompletionList) { wrapper.AddCustom("this"); } }
IEnumerable<ICompletionData> HandleObjectInitializer(SyntaxTree unit, AstNode n) { var p = n.Parent; while (p != null && !(p is ObjectCreateExpression)) { p = p.Parent; } var parent = n.Parent as ArrayInitializerExpression; if (parent == null) return null; if (parent.IsSingleElement) parent = (ArrayInitializerExpression)parent.Parent; if (p != null) { var contextList = new CompletionDataWrapper(this); var initializerResult = ResolveExpression(p); IType initializerType = null; if (initializerResult.Result is DynamicInvocationResolveResult) { var dr = (DynamicInvocationResolveResult)initializerResult.Result; var constructor = (dr.Target as MethodGroupResolveResult).Methods.FirstOrDefault(); if (constructor != null) initializerType = constructor.DeclaringType; } else { initializerType = initializerResult != null ? initializerResult.Result.Type : null; } if (initializerType != null && initializerType.Kind != TypeKind.Unknown) { // check 3 cases: // 1) New initalizer { xpr // 2) Object initializer { prop = val1, field = val2, xpr // 3) Array initializer { new Foo (), a, xpr // in case 1 all object/array initializer options should be given - in the others not. AstNode prev = null; if (parent.Elements.Count > 1) { prev = parent.Elements.First(); if (prev is ArrayInitializerExpression && ((ArrayInitializerExpression)prev).IsSingleElement) prev = ((ArrayInitializerExpression)prev).Elements.FirstOrDefault(); } if (prev != null && !(prev is NamedExpression)) { AddContextCompletion(contextList, GetState(), n); // case 3) return contextList.Result; } var lookup = new MemberLookup(ctx.CurrentTypeDefinition, Compilation.MainAssembly); bool isProtectedAllowed = ctx.CurrentTypeDefinition != null && initializerType.GetDefinition() != null ? ctx.CurrentTypeDefinition.IsDerivedFrom(initializerType.GetDefinition()) : false; foreach (var m in initializerType.GetMembers (m => m.SymbolKind == SymbolKind.Field)) { var f = m as IField; if (f != null && (f.IsReadOnly || f.IsConst)) continue; if (lookup.IsAccessible(m, isProtectedAllowed)) { var data = contextList.AddMember(m); if (data != null) data.DisplayFlags |= DisplayFlags.NamedArgument; } } foreach (IProperty m in initializerType.GetMembers (m => m.SymbolKind == SymbolKind.Property)) { if (m.CanSet && lookup.IsAccessible(m.Setter, isProtectedAllowed)) { var data = contextList.AddMember(m); if (data != null) data.DisplayFlags |= DisplayFlags.NamedArgument; } } if (prev != null && (prev is NamedExpression)) { // case 2) return contextList.Result; } // case 1) // check if the object is a list, if not only provide object initalizers var list = typeof(System.Collections.IList).ToTypeReference().Resolve(Compilation); if (initializerType.Kind != TypeKind.Array && list != null) { var def = initializerType.GetDefinition(); if (def != null && !def.IsDerivedFrom(list.GetDefinition())) return contextList.Result; } AddContextCompletion(contextList, GetState(), n); return contextList.Result; } } return null; }
void AddTypesAndNamespaces(CompletionDataWrapper wrapper, CSharpResolver state, AstNode node, Func<IType, IType> typePred = null, Predicate<IMember> memberPred = null, Action<ICompletionData, IType> callback = null, bool onlyAddConstructors = false) { var lookup = new MemberLookup(ctx.CurrentTypeDefinition, Compilation.MainAssembly); if (currentType != null) { for (var ct = ctx.CurrentTypeDefinition; ct != null; ct = ct.DeclaringTypeDefinition) { foreach (var nestedType in ct.GetNestedTypes ()) { if (!lookup.IsAccessible(nestedType.GetDefinition(), true)) continue; if (onlyAddConstructors) { if (!nestedType.GetConstructors().Any(c => lookup.IsAccessible(c, true))) continue; } if (typePred == null) { if (onlyAddConstructors) wrapper.AddConstructors(nestedType, false, IsAttributeContext(node)); else wrapper.AddType(nestedType, false, IsAttributeContext(node)); continue; } var type = typePred(nestedType); if (type != null) { var a2 = onlyAddConstructors ? wrapper.AddConstructors(type, false, IsAttributeContext(node)) : wrapper.AddType(type, false, IsAttributeContext(node)); if (a2 != null && callback != null) { callback(a2, type); } } continue; } } if (this.currentMember != null && !(node is AstType)) { var def = ctx.CurrentTypeDefinition; if (def == null && currentType != null) def = Compilation.MainAssembly.GetTypeDefinition(currentType.FullTypeName); if (def != null) { bool isProtectedAllowed = true; foreach (var member in def.GetMembers (m => currentMember.IsStatic ? m.IsStatic : true)) { if (member is IMethod && ((IMethod)member).FullName == "System.Object.Finalize") { continue; } if (member.SymbolKind == SymbolKind.Operator) { continue; } if (member.IsExplicitInterfaceImplementation) { continue; } if (!lookup.IsAccessible(member, isProtectedAllowed)) { continue; } if (memberPred == null || memberPred(member)) { wrapper.AddMember(member); } } var declaring = def.DeclaringTypeDefinition; while (declaring != null) { foreach (var member in declaring.GetMembers (m => m.IsStatic)) { if (memberPred == null || memberPred(member)) { wrapper.AddMember(member); } } declaring = declaring.DeclaringTypeDefinition; } } } if (ctx.CurrentTypeDefinition != null) { foreach (var p in ctx.CurrentTypeDefinition.TypeParameters) { wrapper.AddTypeParameter(p); } } } var scope = ctx.CurrentUsingScope; for (var n = scope; n != null; n = n.Parent) { foreach (var pair in n.UsingAliases) { wrapper.AddAlias(pair.Key); } foreach (var alias in n.ExternAliases) { wrapper.AddAlias(alias); } foreach (var u in n.Usings) { foreach (var type in u.Types) { if (!lookup.IsAccessible(type, false)) continue; IType addType = typePred != null ? typePred(type) : type; if (onlyAddConstructors && addType != null) { if (!addType.GetConstructors().Any(c => lookup.IsAccessible(c, true))) continue; } if (addType != null) { var a = onlyAddConstructors ? wrapper.AddConstructors(addType, false, IsAttributeContext(node)) : wrapper.AddType(addType, false, IsAttributeContext(node)); if (a != null && callback != null) { callback(a, type); } } } } foreach (var type in n.Namespace.Types) { if (!lookup.IsAccessible(type, false)) continue; IType addType = typePred != null ? typePred(type) : type; if (onlyAddConstructors && addType != null) { if (!addType.GetConstructors().Any(c => lookup.IsAccessible(c, true))) continue; } if (addType != null) { var a2 = onlyAddConstructors ? wrapper.AddConstructors(addType, false, IsAttributeContext(node)) : wrapper.AddType(addType, false); if (a2 != null && callback != null) { callback(a2, type); } } } } for (var n = scope; n != null; n = n.Parent) { foreach (var curNs in n.Namespace.ChildNamespaces) { wrapper.AddNamespace(lookup, curNs); } } if (node is AstType && node.Parent is Constraint && IncludeKeywordsInCompletionList) { wrapper.AddCustom("new()"); } if (AutomaticallyAddImports) { state = GetState(); ICompletionData[] importData; var namespaces = new List<INamespace>(); for (var n = ctx.CurrentUsingScope; n != null; n = n.Parent) { namespaces.Add(n.Namespace); foreach (var u in n.Usings) namespaces.Add(u); } if (this.CompletionEngineCache != null && ListEquals(namespaces, CompletionEngineCache.namespaces)) { importData = CompletionEngineCache.importCompletion; } else { // flatten usings var importList = new List<ICompletionData>(); var dict = new Dictionary<string, Dictionary<string, ICompletionData>>(); foreach (var type in Compilation.GetAllTypeDefinitions ()) { if (!lookup.IsAccessible(type, false)) continue; if (namespaces.Any(n => n.FullName == type.Namespace)) continue; bool useFullName = false; foreach (var ns in namespaces) { if (ns.GetTypeDefinition(type.Name, type.TypeParameterCount) != null) { useFullName = true; break; } } if (onlyAddConstructors) { if (!type.GetConstructors().Any(c => lookup.IsAccessible(c, true))) continue; } var data = factory.CreateImportCompletionData(type, useFullName, onlyAddConstructors); Dictionary<string, ICompletionData> createdDict; if (!dict.TryGetValue(type.Name, out createdDict)) { createdDict = new Dictionary<string, ICompletionData>(); dict.Add(type.Name, createdDict); } ICompletionData oldData; if (!createdDict.TryGetValue(type.Namespace, out oldData)) { importList.Add(data); createdDict.Add(type.Namespace, data); } else { oldData.AddOverload(data); } } importData = importList.ToArray(); if (CompletionEngineCache != null) { CompletionEngineCache.namespaces = namespaces; CompletionEngineCache.importCompletion = importData; } } foreach (var data in importData) { wrapper.Result.Add(data); } } }
IEnumerable<ICompletionData> MagicKeyCompletion(char completionChar, bool controlSpace, out bool isComplete) { isComplete = false; ExpressionResolveResult resolveResult; switch (completionChar) { // Magic key completion case ':': var text = GetMemberTextToCaret(); var lexer = new MiniLexer(text.Item1); lexer.Parse(); if (lexer.IsInSingleComment || lexer.IsInChar || lexer.IsInMultiLineComment || lexer.IsInPreprocessorDirective) { return Enumerable.Empty<ICompletionData>(); } if (lexer.IsInString || lexer.IsInVerbatimString) return HandleStringFormatItems(); return HandleMemberReferenceCompletion(GetExpressionBeforeCursor()); case '"': text = GetMemberTextToCaret(); lexer = new MiniLexer(text.Item1); lexer.Parse(); if (lexer.IsInSingleComment || lexer.IsInChar || lexer.IsInMultiLineComment || lexer.IsInPreprocessorDirective) { return Enumerable.Empty<ICompletionData>(); } if (lexer.IsInString || lexer.IsInVerbatimString) return HandleToStringFormatItems(); return Enumerable.Empty<ICompletionData>(); case '.': if (IsInsideCommentStringOrDirective()) { return Enumerable.Empty<ICompletionData>(); } return HandleMemberReferenceCompletion(GetExpressionBeforeCursor()); case '#': if (!IsInPreprocessorDirective()) return null; return GetDirectiveCompletionData(); // XML doc completion case '<': if (IsInsideDocComment()) { return GetXmlDocumentationCompletionData(); } if (controlSpace) { return DefaultControlSpaceItems(ref isComplete); } return null; case '>': if (!IsInsideDocComment()) { if (offset > 2 && document.GetCharAt(offset - 2) == '-' && !IsInsideCommentStringOrDirective()) { return HandleMemberReferenceCompletion(GetExpressionBeforeCursor()); } return null; } return null; // Parameter completion case '(': if (IsInsideCommentStringOrDirective()) { return null; } var invoke = GetInvocationBeforeCursor(true); if (invoke == null) { if (controlSpace) return DefaultControlSpaceItems(ref isComplete, invoke); return null; } if (invoke.Node is TypeOfExpression) { return CreateTypeList(); } var invocationResult = ResolveExpression(invoke); if (invocationResult == null) { return null; } var methodGroup = invocationResult.Result as MethodGroupResolveResult; if (methodGroup != null) { return CreateParameterCompletion( methodGroup, invocationResult.Resolver, invoke.Node, invoke.Unit, 0, controlSpace ); } if (controlSpace) { return DefaultControlSpaceItems(ref isComplete, invoke); } return null; case '=': return controlSpace ? DefaultControlSpaceItems(ref isComplete) : null; case ',': int cpos2; if (!GetParameterCompletionCommandOffset(out cpos2)) { return null; } // completionContext = CompletionWidget.CreateCodeCompletionContext (cpos2); // int currentParameter2 = MethodParameterDataProvider.GetCurrentParameterIndex (CompletionWidget, completionContext) - 1; // return CreateParameterCompletion (CreateResolver (), location, ExpressionContext.MethodBody, provider.Methods, currentParameter); break; // Completion on space: case ' ': int tokenIndex = offset; string token = GetPreviousToken(ref tokenIndex, false); if (IsInsideCommentStringOrDirective()) { return null; } // check propose name, for context <variable name> <ctrl+space> (but only in control space context) //IType isAsType = null; var isAsExpression = GetExpressionAt(offset); if (controlSpace && isAsExpression != null && isAsExpression.Node is VariableDeclarationStatement && token != "new") { var parent = isAsExpression.Node as VariableDeclarationStatement; var proposeNameList = new CompletionDataWrapper(this); if (parent.Variables.Count != 1) return DefaultControlSpaceItems(ref isComplete, isAsExpression, controlSpace); foreach (var possibleName in GenerateNameProposals (parent.Type)) { if (possibleName.Length > 0) { proposeNameList.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString())); } } AutoSelect = false; AutoCompleteEmptyMatch = false; isComplete = true; return proposeNameList.Result; } // int tokenIndex = offset; // string token = GetPreviousToken (ref tokenIndex, false); // if (result.ExpressionContext == ExpressionContext.ObjectInitializer) { // resolver = CreateResolver (); // ExpressionContext exactContext = new NewCSharpExpressionFinder (dom).FindExactContextForObjectInitializer (document, resolver.Unit, Document.FileName, resolver.CallingType); // IReturnType objectInitializer = ((ExpressionContext.TypeExpressionContext)exactContext).UnresolvedType; // if (objectInitializer != null && objectInitializer.ArrayDimensions == 0 && objectInitializer.PointerNestingLevel == 0 && (token == "{" || token == ",")) // return CreateCtrlSpaceCompletionData (completionContext, result); // } if (token == "=") { int j = tokenIndex; string prevToken = GetPreviousToken(ref j, false); if (prevToken == "=" || prevToken == "+" || prevToken == "-" || prevToken == "!") { token = prevToken + token; tokenIndex = j; } } switch (token) { case "(": case ",": int cpos; if (!GetParameterCompletionCommandOffset(out cpos)) { break; } int currentParameter = GetCurrentParameterIndex(cpos - 1, this.offset) - 1; if (currentParameter < 0) { return null; } invoke = GetInvocationBeforeCursor(token == "("); if (invoke == null) { return null; } invocationResult = ResolveExpression(invoke); if (invocationResult == null) { return null; } methodGroup = invocationResult.Result as MethodGroupResolveResult; if (methodGroup != null) { return CreateParameterCompletion( methodGroup, invocationResult.Resolver, invoke.Node, invoke.Unit, currentParameter, controlSpace); } return null; case "=": case "==": case "!=": GetPreviousToken(ref tokenIndex, false); var expressionOrVariableDeclaration = GetExpressionAt(tokenIndex); if (expressionOrVariableDeclaration == null) { return null; } resolveResult = ResolveExpression(expressionOrVariableDeclaration); if (resolveResult == null) { return null; } if (resolveResult.Result.Type.Kind == TypeKind.Enum) { var wrapper = new CompletionDataWrapper(this); AddContextCompletion( wrapper, resolveResult.Resolver, expressionOrVariableDeclaration.Node); AddEnumMembers(wrapper, resolveResult.Result.Type, resolveResult.Resolver); AutoCompleteEmptyMatch = false; return wrapper.Result; } // // if (resolvedType.FullName == DomReturnType.Bool.FullName) { // CompletionDataList completionList = new ProjectDomCompletionDataList (); // CompletionDataCollector cdc = new CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, resolver.CallingType, location); // completionList.AutoCompleteEmptyMatch = false; // cdc.Add ("true", "md-keyword"); // cdc.Add ("false", "md-keyword"); // resolver.AddAccessibleCodeCompletionData (result.ExpressionContext, cdc); // return completionList; // } // if (resolvedType.ClassType == ClassType.Delegate && token == "=") { // CompletionDataList completionList = new ProjectDomCompletionDataList (); // string parameterDefinition = AddDelegateHandlers (completionList, resolvedType); // string varName = GetPreviousMemberReferenceExpression (tokenIndex); // completionList.Add (new EventCreationCompletionData (document, varName, resolvedType, null, parameterDefinition, resolver.CallingMember, resolvedType)); // // CompletionDataCollector cdc = new CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, resolver.CallingType, location); // resolver.AddAccessibleCodeCompletionData (result.ExpressionContext, cdc); // foreach (var data in completionList) { // if (data is MemberCompletionData) // ((MemberCompletionData)data).IsDelegateExpected = true; // } // return completionList; // } return null; case "+=": case "-=": GetPreviousToken(ref tokenIndex, false); expressionOrVariableDeclaration = GetExpressionAt(tokenIndex); if (expressionOrVariableDeclaration == null) { return null; } resolveResult = ResolveExpression(expressionOrVariableDeclaration); if (resolveResult == null) { return null; } var mrr = resolveResult.Result as MemberResolveResult; if (mrr != null) { var evt = mrr.Member as IEvent; if (evt == null) { return null; } var delegateType = evt.ReturnType; if (delegateType.Kind != TypeKind.Delegate) { return null; } var wrapper = new CompletionDataWrapper(this); if (currentType != null) { // bool includeProtected = DomType.IncludeProtected (dom, typeFromDatabase, resolver.CallingType); foreach (var method in ctx.CurrentTypeDefinition.Methods) { if (MatchDelegate(delegateType, method) /* && method.IsAccessibleFrom (dom, resolver.CallingType, resolver.CallingMember, includeProtected) &&*/) { wrapper.AddMember(method); // data.SetText (data.CompletionText + ";"); } } } if (token == "+=") { string parameterDefinition = AddDelegateHandlers( wrapper, delegateType ); string varName = GetPreviousMemberReferenceExpression(tokenIndex); wrapper.Result.Add( factory.CreateEventCreationCompletionData( varName, delegateType, evt, parameterDefinition, currentMember, currentType) ); } return wrapper.Result; } return null; case ":": if (currentMember == null) { token = GetPreviousToken(ref tokenIndex, false); token = GetPreviousToken(ref tokenIndex, false); if (token == "enum") return HandleEnumContext(); var wrapper = new CompletionDataWrapper(this); AddTypesAndNamespaces( wrapper, GetState(), null, t => { if (currentType != null && currentType.ReflectionName.Equals(t.ReflectionName)) return null; var def = t.GetDefinition(); if (def != null && t.Kind != TypeKind.Interface && (def.IsSealed ||def.IsStatic)) return null; return t; } ); return wrapper.Result; } return null; } var keywordCompletion = HandleKeywordCompletion(tokenIndex, token); if (keywordCompletion == null && controlSpace) { goto default; } return keywordCompletion; // Automatic completion default: if (IsInsideCommentStringOrDirective()) { tokenIndex = offset; token = GetPreviousToken(ref tokenIndex, false); if (IsInPreprocessorDirective() && (token.Length == 1 && char.IsLetter(completionChar) || controlSpace)) { while (token != null && document.GetCharAt(tokenIndex - 1) != '#') { token = GetPreviousToken(ref tokenIndex, false); } if (token != null) return HandleKeywordCompletion(tokenIndex, token); } return null; } char prevCh = offset > 2 ? document.GetCharAt(offset - 2) : ';'; char nextCh = offset < document.TextLength ? document.GetCharAt(offset) : ' '; const string allowedChars = ";,.[](){}+-*/%^?:&|~!<>="; if ((!Char.IsWhiteSpace(nextCh) && allowedChars.IndexOf(nextCh) < 0) || !(Char.IsWhiteSpace(prevCh) || allowedChars.IndexOf(prevCh) >= 0)) { if (!controlSpace) return null; } if (IsInLinqContext(offset)) { if (!controlSpace && !(char.IsLetter(completionChar) || completionChar == '_')) { return null; } tokenIndex = offset; token = GetPreviousToken(ref tokenIndex, false); // token last typed if (!char.IsWhiteSpace(completionChar) && !linqKeywords.Contains(token)) { token = GetPreviousToken(ref tokenIndex, false); } // token last typed if (linqKeywords.Contains(token)) { if (token == "from") { // after from no auto code completion. return null; } return DefaultControlSpaceItems(ref isComplete); } var dataList = new CompletionDataWrapper(this); AddKeywords(dataList, linqKeywords); return dataList.Result; } if (currentType != null && currentType.Kind == TypeKind.Enum) { if (!char.IsLetter(completionChar)) return null; return HandleEnumContext(); } var contextList = new CompletionDataWrapper(this); var identifierStart = GetExpressionAtCursor(); if (!(char.IsLetter(completionChar) || completionChar == '_') && (!controlSpace || identifierStart == null)) { return controlSpace ? HandleAccessorContext() ?? DefaultControlSpaceItems(ref isComplete, identifierStart) : null; } if (identifierStart != null) { if (identifierStart.Node is TypeParameterDeclaration) { return null; } if (identifierStart.Node is MemberReferenceExpression) { return HandleMemberReferenceCompletion( new ExpressionResult( ((MemberReferenceExpression)identifierStart.Node).Target, identifierStart.Unit ) ); } if (identifierStart.Node is Identifier) { if (identifierStart.Node.Parent is GotoStatement) return null; // May happen in variable names return controlSpace ? DefaultControlSpaceItems(ref isComplete, identifierStart) : null; } if (identifierStart.Node is VariableInitializer && location <= ((VariableInitializer)identifierStart.Node).NameToken.EndLocation) { return controlSpace ? HandleAccessorContext() ?? DefaultControlSpaceItems(ref isComplete, identifierStart) : null; } if (identifierStart.Node is CatchClause) { if (((CatchClause)identifierStart.Node).VariableNameToken.IsInside(location)) { return null; } } if (identifierStart.Node is AstType && identifierStart.Node.Parent is CatchClause) { return HandleCatchClauseType(identifierStart); } var pDecl = identifierStart.Node as ParameterDeclaration; if (pDecl != null && pDecl.Parent is LambdaExpression) { return null; } } // Do not pop up completion on identifier identifier (should be handled by keyword completion). tokenIndex = offset - 1; token = GetPreviousToken(ref tokenIndex, false); if (token == "class" || token == "interface" || token == "struct" || token == "enum" || token == "namespace") { // after these always follows a name return null; } var keywordresult = HandleKeywordCompletion(tokenIndex, token); if (keywordresult != null) { return keywordresult; } if ((!Char.IsWhiteSpace(nextCh) && allowedChars.IndexOf(nextCh) < 0) || !(Char.IsWhiteSpace(prevCh) || allowedChars.IndexOf(prevCh) >= 0)) { if (controlSpace) return DefaultControlSpaceItems(ref isComplete, identifierStart); } int prevTokenIndex = tokenIndex; var prevToken2 = GetPreviousToken(ref prevTokenIndex, false); if (prevToken2 == "delegate") { // after these always follows a name return null; } if (identifierStart == null && !string.IsNullOrEmpty(token) && !IsInsideCommentStringOrDirective() && (prevToken2 == ";" || prevToken2 == "{" || prevToken2 == "}")) { char last = token [token.Length - 1]; if (char.IsLetterOrDigit(last) || last == '_' || token == ">") { return HandleKeywordCompletion(tokenIndex, token); } } if (identifierStart == null) { var accCtx = HandleAccessorContext(); if (accCtx != null) { return accCtx; } return DefaultControlSpaceItems(ref isComplete, null, controlSpace); } CSharpResolver csResolver; AstNode n = identifierStart.Node; if (n.Parent is NamedArgumentExpression) n = n.Parent; if (n != null && n.Parent is AnonymousTypeCreateExpression) { AutoSelect = false; } // new { b$ } if (n is IdentifierExpression && n.Parent is AnonymousTypeCreateExpression) return null; // Handle foreach (type name _ if (n is IdentifierExpression) { var prev = n.GetPrevNode() as ForeachStatement; while (prev != null && prev.EmbeddedStatement is ForeachStatement) prev = (ForeachStatement)prev.EmbeddedStatement; if (prev != null && prev.InExpression.IsNull) { if (IncludeKeywordsInCompletionList) contextList.AddCustom("in"); return contextList.Result; } } // Handle object/enumerable initialzer expressions: "new O () { P$" if (n is IdentifierExpression && n.Parent is ArrayInitializerExpression && !(n.Parent.Parent is ArrayCreateExpression)) { var result = HandleObjectInitializer(identifierStart.Unit, n); if (result != null) return result; } if (n != null && n.Parent is InvocationExpression || n.Parent is ParenthesizedExpression && n.Parent.Parent is InvocationExpression) { if (n.Parent is ParenthesizedExpression) n = n.Parent; var invokeParent = (InvocationExpression)n.Parent; var invokeResult = ResolveExpression( invokeParent.Target ); var mgr = invokeResult != null ? invokeResult.Result as MethodGroupResolveResult : null; if (mgr != null) { int idx = 0; foreach (var arg in invokeParent.Arguments) { if (arg == n) { break; } idx++; } foreach (var method in mgr.Methods) { if (idx < method.Parameters.Count && method.Parameters [idx].Type.Kind == TypeKind.Delegate) { AutoSelect = false; AutoCompleteEmptyMatch = false; } foreach (var p in method.Parameters) { contextList.AddNamedParameterVariable(p); } } idx++; foreach (var list in mgr.GetEligibleExtensionMethods (true)) { foreach (var method in list) { if (idx < method.Parameters.Count && method.Parameters [idx].Type.Kind == TypeKind.Delegate) { AutoSelect = false; AutoCompleteEmptyMatch = false; } } } } } if (n != null && n.Parent is ObjectCreateExpression) { var invokeResult = ResolveExpression(n.Parent); var mgr = invokeResult != null ? invokeResult.Result as ResolveResult : null; if (mgr != null) { foreach (var constructor in mgr.Type.GetConstructors ()) { foreach (var p in constructor.Parameters) { contextList.AddVariable(p); } } } } if (n is IdentifierExpression) { var bop = n.Parent as BinaryOperatorExpression; Expression evaluationExpr = null; if (bop != null && bop.Right == n && (bop.Operator == BinaryOperatorType.Equality || bop.Operator == BinaryOperatorType.InEquality)) { evaluationExpr = bop.Left; } // check for compare to enum case if (evaluationExpr != null) { resolveResult = ResolveExpression(evaluationExpr); if (resolveResult != null && resolveResult.Result.Type.Kind == TypeKind.Enum) { var wrapper = new CompletionDataWrapper(this); AddContextCompletion( wrapper, resolveResult.Resolver, evaluationExpr ); AddEnumMembers(wrapper, resolveResult.Result.Type, resolveResult.Resolver); AutoCompleteEmptyMatch = false; return wrapper.Result; } } } if (n is Identifier && n.Parent is ForeachStatement) { if (controlSpace) { return DefaultControlSpaceItems(ref isComplete); } return null; } if (n is ArrayInitializerExpression) { // check for new [] {...} expression -> no need to resolve the type there var parent = n.Parent as ArrayCreateExpression; if (parent != null && parent.Type.IsNull) { return DefaultControlSpaceItems(ref isComplete); } var initalizerResult = ResolveExpression(n.Parent); var concreteNode = identifierStart.Unit.GetNodeAt<IdentifierExpression>(location); // check if we're on the right side of an initializer expression if (concreteNode != null && concreteNode.Parent != null && concreteNode.Parent.Parent != null && concreteNode.Identifier != "a" && concreteNode.Parent.Parent is NamedExpression) { return DefaultControlSpaceItems(ref isComplete); } if (initalizerResult != null && initalizerResult.Result.Type.Kind != TypeKind.Unknown) { foreach (var property in initalizerResult.Result.Type.GetProperties ()) { if (!property.IsPublic) { continue; } var data = contextList.AddMember(property); if (data != null) data.DisplayFlags |= DisplayFlags.NamedArgument; } foreach (var field in initalizerResult.Result.Type.GetFields ()) { if (!field.IsPublic) { continue; } var data = contextList.AddMember(field); if (data != null) data.DisplayFlags |= DisplayFlags.NamedArgument; } return contextList.Result; } return DefaultControlSpaceItems(ref isComplete); } if (IsAttributeContext(n)) { // add attribute targets if (currentType == null) { contextList.AddCustom("assembly"); contextList.AddCustom("module"); contextList.AddCustom("type"); } else { contextList.AddCustom("param"); contextList.AddCustom("field"); contextList.AddCustom("property"); contextList.AddCustom("method"); contextList.AddCustom("event"); } contextList.AddCustom("return"); } if (n is MemberType) { resolveResult = ResolveExpression( ((MemberType)n).Target ); return CreateTypeAndNamespaceCompletionData( location, resolveResult.Result, ((MemberType)n).Target, resolveResult.Resolver ); } if (n != null/* && !(identifierStart.Item2 is TypeDeclaration)*/) { csResolver = new CSharpResolver(ctx); var nodes = new List<AstNode>(); nodes.Add(n); if (n.Parent is ICSharpCode.NRefactory.CSharp.Attribute) { nodes.Add(n.Parent); } var astResolver = CompletionContextProvider.GetResolver(csResolver, identifierStart.Unit); astResolver.ApplyNavigator(new NodeListResolveVisitorNavigator(nodes)); try { csResolver = astResolver.GetResolverStateBefore(n); } catch (Exception) { csResolver = GetState(); } // add attribute properties. if (n.Parent is ICSharpCode.NRefactory.CSharp.Attribute) { var rr = ResolveExpression(n.Parent); if (rr != null) AddAttributeProperties(contextList, rr.Result); } } else { csResolver = GetState(); } // identifier has already started with the first letter offset--; AddContextCompletion( contextList, csResolver, identifierStart.Node ); return contextList.Result; // if (stub.Parent is BlockStatement) // result = FindExpression (dom, completionContext, -1); // if (result == null) // return null; // else if (result.ExpressionContext != ExpressionContext.IdentifierExpected) { // triggerWordLength = 1; // bool autoSelect = true; // IType returnType = null; // if ((prevCh == ',' || prevCh == '(') && GetParameterCompletionCommandOffset (out cpos)) { // ctx = CompletionWidget.CreateCodeCompletionContext (cpos); // NRefactoryParameterDataProvider dataProvider = ParameterCompletionCommand (ctx) as NRefactoryParameterDataProvider; // if (dataProvider != null) { // int i = dataProvider.GetCurrentParameterIndex (CompletionWidget, ctx) - 1; // foreach (var method in dataProvider.Methods) { // if (i < method.Parameters.Count) { // returnType = dom.GetType (method.Parameters [i].ReturnType); // autoSelect = returnType == null || returnType.ClassType != ClassType.Delegate; // break; // } // } // } // } // // Bug 677531 - Auto-complete doesn't always highlight generic parameter in method signature // //if (result.ExpressionContext == ExpressionContext.TypeName) // // autoSelect = false; // CompletionDataList dataList = CreateCtrlSpaceCompletionData (completionContext, result); // AddEnumMembers (dataList, returnType); // dataList.AutoSelect = autoSelect; // return dataList; // } else { // result = FindExpression (dom, completionContext, 0); // tokenIndex = offset; // // // check foreach case, unfortunately the expression finder is too dumb to handle full type names // // should be overworked if the expression finder is replaced with a mcs ast based analyzer. // var possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // starting letter // possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // varname // // // read return types to '(' token // possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // varType // if (possibleForeachToken == ">") { // while (possibleForeachToken != null && possibleForeachToken != "(") { // possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // } // } else { // possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // ( // if (possibleForeachToken == ".") // while (possibleForeachToken != null && possibleForeachToken != "(") // possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // } // possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // foreach // // if (possibleForeachToken == "foreach") { // result.ExpressionContext = ExpressionContext.ForeachInToken; // } else { // return null; // // result.ExpressionContext = ExpressionContext.IdentifierExpected; // } // result.Expression = ""; // result.Region = DomRegion.Empty; // // return CreateCtrlSpaceCompletionData (completionContext, result); // } // break; } return null; }
IEnumerable<ICompletionData> HandleKeywordCompletion(int wordStart, string word) { if (IsInsideCommentStringOrDirective()) { if (IsInPreprocessorDirective()) { if (word == "if" || word == "elif") { if (wordStart > 0 && document.GetCharAt(wordStart - 1) == '#') { return factory.CreatePreProcessorDefinesCompletionData(); } } } return null; } switch (word) { case "namespace": return null; case "using": if (currentType != null) { return null; } var wrapper = new CompletionDataWrapper(this); AddTypesAndNamespaces(wrapper, GetState(), null, t => null); return wrapper.Result; case "case": return CreateCaseCompletionData(location); // case ",": // case ":": // if (result.ExpressionContext == ExpressionContext.InheritableType) { // IType cls = NRefactoryResolver.GetTypeAtCursor (Document.CompilationUnit, Document.FileName, new TextLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset)); // CompletionDataList completionList = new ProjectDomCompletionDataList (); // List<string > namespaceList = GetUsedNamespaces (); // var col = new CSharpTextEditorCompletion.CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, null, location); // bool isInterface = false; // HashSet<string > baseTypeNames = new HashSet<string> (); // if (cls != null) { // baseTypeNames.Add (cls.Name); // if (cls.ClassType == ClassType.Struct) // isInterface = true; // } // int tokenIndex = offset; // // // Search base types " : [Type1, ... ,TypeN,] <Caret>" // string token = null; // do { // token = GetPreviousToken (ref tokenIndex, false); // if (string.IsNullOrEmpty (token)) // break; // token = token.Trim (); // if (Char.IsLetterOrDigit (token [0]) || token [0] == '_') { // IType baseType = dom.SearchType (Document.CompilationUnit, cls, result.Region.Start, token); // if (baseType != null) { // if (baseType.ClassType != ClassType.Interface) // isInterface = true; // baseTypeNames.Add (baseType.Name); // } // } // } while (token != ":"); // foreach (object o in dom.GetNamespaceContents (namespaceList, true, true)) { // IType type = o as IType; // if (type != null && (type.IsStatic || type.IsSealed || baseTypeNames.Contains (type.Name) || isInterface && type.ClassType != ClassType.Interface)) { // continue; // } // if (o is Namespace && !namespaceList.Any (ns => ns.StartsWith (((Namespace)o).FullName))) // continue; // col.Add (o); // } // // Add inner classes // Stack<IType > innerStack = new Stack<IType> (); // innerStack.Push (cls); // while (innerStack.Count > 0) { // IType curType = innerStack.Pop (); // if (curType == null) // continue; // foreach (IType innerType in curType.InnerTypes) { // if (innerType != cls) // // don't add the calling class as possible base type // col.Add (innerType); // } // if (curType.DeclaringType != null) // innerStack.Push (curType.DeclaringType); // } // return completionList; // } // break; case "is": case "as": if (currentType == null) { return null; } IType isAsType = null; var isAsExpression = GetExpressionAt(wordStart); if (isAsExpression != null) { var parent = isAsExpression.Node.Parent; if (parent is VariableInitializer) { parent = parent.Parent; } if (parent is VariableDeclarationStatement) { var resolved = ResolveExpression(parent); if (resolved != null) { isAsType = resolved.Result.Type; } } } var isAsWrapper = new CompletionDataWrapper(this); var def = isAsType != null ? isAsType.GetDefinition() : null; AddTypesAndNamespaces( isAsWrapper, GetState(), null, t => t.GetDefinition() == null || def == null || t.GetDefinition().IsDerivedFrom(def) ? t : null, m => false); AddKeywords(isAsWrapper, primitiveTypesKeywords); return isAsWrapper.Result; // { // CompletionDataList completionList = new ProjectDomCompletionDataList (); // ExpressionResult expressionResult = FindExpression (dom, completionContext, wordStart - document.Caret.Offset); // NRefactoryResolver resolver = CreateResolver (); // ResolveResult resolveResult = resolver.Resolve (expressionResult, new TextLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset)); // if (resolveResult != null && resolveResult.ResolvedType != null) { // CompletionDataCollector col = new CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, resolver.CallingType, location); // IType foundType = null; // if (word == "as") { // ExpressionContext exactContext = new NewCSharpExpressionFinder (dom).FindExactContextForAsCompletion (document, Document.CompilationUnit, Document.FileName, resolver.CallingType); // if (exactContext is ExpressionContext.TypeExpressionContext) { // foundType = resolver.SearchType (((ExpressionContext.TypeExpressionContext)exactContext).Type); // AddAsCompletionData (col, foundType); // } // } // // if (foundType == null) // foundType = resolver.SearchType (resolveResult.ResolvedType); // // if (foundType != null) { // if (foundType.ClassType == ClassType.Interface) // foundType = resolver.SearchType (DomReturnType.Object); // // foreach (IType type in dom.GetSubclasses (foundType)) { // if (type.IsSpecialName || type.Name.StartsWith ("<")) // continue; // AddAsCompletionData (col, type); // } // } // List<string > namespaceList = GetUsedNamespaces (); // foreach (object o in dom.GetNamespaceContents (namespaceList, true, true)) { // if (o is IType) { // IType type = (IType)o; // if (type.ClassType != ClassType.Interface || type.IsSpecialName || type.Name.StartsWith ("<")) // continue; // // if (foundType != null && !dom.GetInheritanceTree (foundType).Any (x => x.FullName == type.FullName)) // // continue; // AddAsCompletionData (col, type); // continue; // } // if (o is Namespace) // continue; // col.Add (o); // } // return completionList; // } // result.ExpressionContext = ExpressionContext.TypeName; // return CreateCtrlSpaceCompletionData (completionContext, result); // } case "override": // Look for modifiers, in order to find the beginning of the declaration int firstMod = wordStart; int i = wordStart; for (int n = 0; n < 3; n++) { string mod = GetPreviousToken(ref i, true); if (mod == "public" || mod == "protected" || mod == "private" || mod == "internal" || mod == "sealed") { firstMod = i; } else if (mod == "static") { // static methods are not overridable return null; } else { break; } } if (!IsLineEmptyUpToEol()) { return null; } if (currentType != null && (currentType.Kind == TypeKind.Class || currentType.Kind == TypeKind.Struct)) { string modifiers = document.GetText(firstMod, wordStart - firstMod); return GetOverrideCompletionData(currentType, modifiers); } return null; case "partial": // Look for modifiers, in order to find the beginning of the declaration firstMod = wordStart; i = wordStart; for (int n = 0; n < 3; n++) { string mod = GetPreviousToken(ref i, true); if (mod == "public" || mod == "protected" || mod == "private" || mod == "internal" || mod == "sealed") { firstMod = i; } else if (mod == "static") { // static methods are not overridable return null; } else { break; } } if (!IsLineEmptyUpToEol()) { return null; } var state = GetState(); if (state.CurrentTypeDefinition != null && (state.CurrentTypeDefinition.Kind == TypeKind.Class || state.CurrentTypeDefinition.Kind == TypeKind.Struct)) { string modifiers = document.GetText(firstMod, wordStart - firstMod); return GetPartialCompletionData(state.CurrentTypeDefinition, modifiers); } return null; case "public": case "protected": case "private": case "internal": case "sealed": case "static": var accessorContext = HandleAccessorContext(); if (accessorContext != null) { return accessorContext; } return null; case "new": int j = offset - 4; // string token = GetPreviousToken (ref j, true); IType hintType = null; var expressionOrVariableDeclaration = GetNewExpressionAt(j); if (expressionOrVariableDeclaration == null) return null; var astResolver = CompletionContextProvider.GetResolver(GetState(), expressionOrVariableDeclaration.Node.Ancestors.FirstOrDefault(n => n is EntityDeclaration || n is SyntaxTree)); hintType = TypeGuessing.GetValidTypes( astResolver, expressionOrVariableDeclaration.Node ).FirstOrDefault(); return CreateConstructorCompletionData(hintType); case "yield": var yieldDataList = new CompletionDataWrapper(this); DefaultCompletionString = "return"; if (IncludeKeywordsInCompletionList) { yieldDataList.AddCustom("break"); yieldDataList.AddCustom("return"); } return yieldDataList.Result; case "in": var inList = new CompletionDataWrapper(this); var expr = GetExpressionAtCursor(); if (expr == null) return null; var rr = ResolveExpression(expr); AddContextCompletion( inList, rr != null ? rr.Resolver : GetState(), expr.Node ); return inList.Result; } return null; }