public GenerateNamespaceImport GetResult (ProjectDom dom, ICompilationUnit unit, IType type, TextEditorData data) { GenerateNamespaceImport result; if (cache.TryGetValue (type.Namespace, out result)) return result; result = new GenerateNamespaceImport (); cache[type.Namespace] = result; result.InsertNamespace = false; DomLocation location = new DomLocation (data.Caret.Line, data.Caret.Column); foreach (IUsing u in unit.Usings.Where (u => u.ValidRegion.Contains (location))) { if (u.Namespaces.Any (ns => type.Namespace == ns)) { result.GenerateUsing = false; return result; } } result.GenerateUsing = true; string name = type.DecoratedFullName.Substring (type.Namespace.Length + 1); foreach (IUsing u in unit.Usings.Where (u => u.ValidRegion.Contains (location))) { foreach (string ns in u.Namespaces) { if (dom.SearchType (unit, unit.GetTypeAt (location), unit.GetMemberAt (location), ns + "." + name) != null) { result.GenerateUsing = false; result.InsertNamespace = true; return result; } } } return result; }
public InstantiatedParameterType (ProjectDom dom, ITypeParameterMember typeParameterMember, ITypeParameter tp) { IType outerType = typeParameterMember as IType ?? typeParameterMember.DeclaringType; typeparam = tp; compilationUnit = outerType.CompilationUnit; ClassType = ClassType.Class; Modifiers = Modifiers.Public; Name = tp.Name; Namespace = outerType.DecoratedFullName; Location = outerType.Location; DeclaringType = outerType; if (tp.Constraints.Count > 0) ClassType = ClassType.Interface; foreach (IReturnType rt in tp.Constraints) { if (FindCyclicReference (new HashSet<ITypeParameter> () { tp }, outerType, ((DomReturnType)rt).DecoratedFullName)) continue; IType bt = dom.SearchType (typeParameterMember, rt); IReturnType resolvedType = rt; if (bt != null) { resolvedType = new DomReturnType (bt); if (bt.ClassType == ClassType.Interface || BaseType != null) { AddInterfaceImplementation (resolvedType); } else { ClassType = bt.ClassType; BaseType = resolvedType; } } else { AddInterfaceImplementation (resolvedType); } } if (BaseType == null) BaseType = DomReturnType.Object; }
public override INode Visit(IReturnType type, IType contextType) { if (type.GenericArguments.Count == 0 && unit != null) { foreach (IUsing u in unit.Usings) { if (u.IsFromNamespace || u.Aliases.Count == 0 && contextType != null && u.Region.Contains(contextType.Location)) { continue; } foreach (KeyValuePair <string, IReturnType> alias in u.Aliases) { if (alias.Key == type.FullName) { return(Visit(alias.Value, contextType)); } } } } if (currentMethod != null) { IMethod method = null; if (currentMethod.IsOverride) { foreach (IType curType2 in db.GetInheritanceTree(contextType)) { foreach (IMethod curMethod in curType2.SearchMember(currentMethod.Name, true)) { if (!curMethod.IsOverride && curMethod.Parameters.Count == currentMethod.Parameters.Count && curMethod.TypeParameters.Count == currentMethod.TypeParameters.Count) { method = curMethod; break; } } if (method != null) { break; } } } if (method == null) { method = currentMethod; } int idx = currentMethod.GetTypeParameterIndex(type.Name); if (idx >= 0) { ITypeParameter t = method.TypeParameters [idx]; DomReturnType typeParameterReturnType = new DomReturnType(type.FullName); DomType constructedType = new InstantiatedParameterType(db, method, t); if (constructedType.BaseType == null) { constructedType.BaseType = DomReturnType.Object; } constructedType.SourceProjectDom = db; typeParameterReturnType.Type = constructedType; typeParameterReturnType.ArrayDimensions = type.ArrayDimensions; typeParameterReturnType.PointerNestingLevel = type.PointerNestingLevel; for (int i = 0; i < type.ArrayDimensions; i++) { typeParameterReturnType.SetDimension(i, type.GetDimension(i)); } return(typeParameterReturnType); } } IType lookupType = db.SearchType(unit, contextType, resolvePosition, type); if (visitAttribute && lookupType == null && type.Parts.Count > 0) { string oldName = type.Parts [type.Parts.Count - 1].Name; type.Parts [type.Parts.Count - 1].Name += "Attribute"; lookupType = db.SearchType(unit, contextType, resolvePosition, type); if (lookupType == null) { type.Parts [type.Parts.Count - 1].Name = oldName; } } if (lookupType == null) { unresolvedCount++; return(type); } List <IReturnTypePart> parts = new List <IReturnTypePart> (type.Parts.Count); IType curType = lookupType.DeclaringType; int typePart = 0; while (curType != null) { ReturnTypePart newPart = new ReturnTypePart { Name = curType.Name }; newPart.IsGenerated = true; for (int n = curType.TypeParameters.Count - 1; n >= 0; n--) { newPart.AddTypeParameter(new DomReturnType("?")); } if (typePart >= type.Parts.Count || (type.Parts [typePart].Name != newPart.Name || type.Parts [typePart].GenericArguments.Count != newPart.GenericArguments.Count)) { parts.Insert(0, newPart); typePart++; } curType = curType.DeclaringType; } foreach (ReturnTypePart part in type.Parts) { ReturnTypePart newPart = new ReturnTypePart(); newPart.Name = part.Name; foreach (IReturnType ga in part.GenericArguments) { newPart.AddTypeParameter((IReturnType)ga.AcceptVisitor(this, contextType)); } parts.Add(newPart); } DomReturnType rt = new DomReturnType(lookupType.Namespace, parts); // Make sure the whole type is resolved if (parts.Count > 1 && db.SearchType(unit, contextType, resolvePosition, rt) == null) { unresolvedCount++; return(type); } rt.PointerNestingLevel = type.PointerNestingLevel; rt.IsNullable = type.IsNullable; rt.ArrayDimensions = type.ArrayDimensions; for (int n = 0; n < type.ArrayDimensions; n++) { rt.SetDimension(n, type.GetDimension(n)); } return(db.GetSharedReturnType(rt)); }
public override IEnumerable<object> CreateResolveResult (ProjectDom dom, IMember callingMember) { List<object> result = new List<object> (); if (CallingMember != null && !CallingMember.IsStatic) { IType baseType = dom.SearchType (CallingType != null ? CallingType.CompilationUnit : null, CallingType, CallingMember.Location ,CallingType.BaseType ?? DomReturnType.Object); MemberResolveResult.AddType (dom, result, baseType, new BaseMemberDecorator (CallingMember, baseType), StaticResolve, m => m.IsAbstract); } return result; }
// string expression; /* IMember GetLanguageItem (Mono.TextEditor.Document document, LineSegment line, int offset, string expression) { string txt = document.Text; ExpressionResult expressionResult = new ExpressionResult (expression); // ExpressionResult expressionResult = expressionFinder.FindFullExpression (txt, offset); int lineNumber = document.OffsetToLineNumber (offset); expressionResult.Region = new DomRegion (lineNumber, offset - line.Offset, lineNumber, offset + expression.Length - line.Offset); expressionResult.ExpressionContext = ExpressionContext.IdentifierExpected; resolver = new NRefactoryResolver (ctx, doc.CompilationUnit, doc.TextEditor, document.FileName); ResolveResult result = resolver.Resolve (expressionResult, expressionResult.Region.Start); if (result is MemberResolveResult) return ((MemberResolveResult)result).ResolvedMember; return null; }*/ public override void Analyze (Mono.TextEditor.Document doc, LineSegment line, Chunk startChunk, int startOffset, int endOffset) { if (!MonoDevelop.Core.PropertyService.Get ("EnableSemanticHighlighting", false) || doc == null || line == null || startChunk == null) return; ctx = GetParserContext (doc); int lineNumber = doc.OffsetToLineNumber (line.Offset); ParsedDocument parsedDocument = ProjectDomService.GetParsedDocument (ctx, doc.FileName); ICompilationUnit unit = parsedDocument != null ? parsedDocument.CompilationUnit : null; if (unit == null) return; for (Chunk chunk = startChunk; chunk != null; chunk = chunk.Next) { if (chunk.Style != "text") continue; for (int i = chunk.Offset; i < chunk.EndOffset; i++) { char charBefore = i > 0 ? doc.GetCharAt (i - 1) : '}'; if (Char.IsLetter (doc.GetCharAt (i)) && !Char.IsLetterOrDigit (charBefore)) { } else { continue; } int start = i; bool wasWhitespace = false; bool wasDot = false; int bracketCount = 0; while (start > 0) { char ch = doc.GetCharAt (start); if (ch == '\n' || ch == '\r') break; if (wasWhitespace && IsNamePart(ch)) { start++; if (start < chunk.Offset) start = Int32.MaxValue; break; } if (ch == '<') { bracketCount--; if (bracketCount < 0) { start++; break; } start--; wasWhitespace = false; continue; } if (ch == '>') { if (wasWhitespace && !wasDot) break; bracketCount++; start--; wasWhitespace = false; continue; } if (!IsNamePart(ch) && !Char.IsWhiteSpace (ch) && ch != '.') { start++; break; } wasWhitespace = Char.IsWhiteSpace (ch); wasDot = ch == '.' || wasDot && wasWhitespace; start--; } int end = i; int genericCount = 0; wasWhitespace = false; List<Segment> nameSegments = new List<Segment> (); while (end < chunk.EndOffset) { char ch = doc.GetCharAt (end); if (wasWhitespace && IsNamePart(ch)) break; if (ch == '<') { genericCount = 1; while (end < doc.Length) { ch = doc.GetCharAt (end); if (ch == ',') genericCount++; if (ch == '>') { nameSegments.Add (new Segment (end, 1)); break; } end++; } break; } if (!IsNamePart(ch) && !Char.IsWhiteSpace (ch)) break; wasWhitespace = Char.IsWhiteSpace (ch); end++; } if (start >= end) continue; string typeString = doc.GetTextBetween (start, end); IReturnType returnType = NRefactoryResolver.ParseReturnType (new ExpressionResult (typeString)); int nameEndOffset = start; for (; nameEndOffset < end; nameEndOffset++) { char ch = doc.GetCharAt (nameEndOffset); if (nameEndOffset >= i && ch == '<') { nameEndOffset++; break; } } nameSegments.Add (new Segment (i, nameEndOffset - i)); int column = i - line.Offset; IType callingType = unit.GetTypeAt (lineNumber, column); List<IReturnType> genericParams = null; if (genericCount > 0) { genericParams = new List<IReturnType> (); for (int n = 0; n < genericCount; n++) genericParams.Add (new DomReturnType ("A")); } IType type = null; if (ctx != null) type = ctx.SearchType ((MonoDevelop.Projects.Dom.INode)callingType ?? unit, returnType); if (type == null && unit != null && returnType != null) type = unit.GetType (returnType.FullName, returnType.GenericArguments.Count); if (ctx != null && type == null && returnType != null) { returnType.Name += "Attribute"; type = ctx.SearchType ((MonoDevelop.Projects.Dom.INode)callingType ?? unit, returnType); } if (type != null) nameSegments.ForEach (segment => HighlightSegment (startChunk, segment, "keyword.semantic.type")); } } }
public override IType SearchType(ICompilationUnit unit, IType callingClass, DomLocation lookupLocation, string decoratedFullName) { return(decorated.SearchType(unit, callingClass, lookupLocation, decoratedFullName)); }
public override IType SearchType(ICompilationUnit unit, IType callingClass, IMember callingMember, string decoratedFullName) { return(decorated.SearchType(unit, callingClass, callingMember, decoratedFullName)); }