public UnknownCodeContext(ICompilation compilation, IUnresolvedFile file, TextLocation location) : this(compilation) { var curDef = file.GetInnermostTypeDefinition (location); if (curDef != null) { var resolvedDef = curDef.Resolve (context).GetDefinition (); if (resolvedDef != null) { context = context.WithCurrentTypeDefinition (resolvedDef); var curMember = resolvedDef.Members.FirstOrDefault (m => m.Region.FileName == file.FileName && m.Region.Begin <= location && location < m.BodyRegion.End); if (curMember != null) context = context.WithCurrentMember (curMember); } } }
/// <summary> /// Gets the next member after the specified caret position. /// </summary> IUnresolvedEntity GetMemberAfter(ITextEditor editor, int caretLine) { FileName fileName = editor.FileName; IUnresolvedEntity nextElement = null; if (fileName != null) { IUnresolvedFile unresolvedFile = SD.ParserService.ParseFile(fileName, editor.Document); if (unresolvedFile != null) { var currentClass = unresolvedFile.GetInnermostTypeDefinition(caretLine, 0); int nextElementLine = int.MaxValue; if (currentClass == null) { foreach (var c in unresolvedFile.TopLevelTypeDefinitions) { if (c.Region.BeginLine < nextElementLine && c.Region.BeginLine > caretLine) { nextElementLine = c.Region.BeginLine; nextElement = c; } } } else { foreach (var c in currentClass.NestedTypes) { if (c.Region.BeginLine < nextElementLine && c.Region.BeginLine > caretLine) { nextElementLine = c.Region.BeginLine; nextElement = c; } } foreach (var m in currentClass.Members) { if (m.Region.BeginLine < nextElementLine && m.Region.BeginLine > caretLine) { nextElementLine = m.Region.BeginLine; nextElement = m; } } } } } return(nextElement); }
IUnresolvedTypeDefinition GetCurrentClass(SDTask item) { // Tasks are created by parsing, so the parse information for item.FileName should already be present. // If they aren't, that's because the file might have been deleted/renamed in the meantime. // We use GetExistingParseInformation to avoid trying to parse a file that might have been deleted/renamed. IUnresolvedFile parseInfo = SD.ParserService.GetExistingUnresolvedFile(item.FileName); if (parseInfo != null) { var c = parseInfo.GetInnermostTypeDefinition(item.Line, item.Column); if (c != null) { return(c); } } return(null); }
public UnknownCodeContext(ICompilation compilation, IUnresolvedFile file, TextLocation location) : this(compilation) { var curDef = file.GetInnermostTypeDefinition(location); if (curDef != null) { var resolvedDef = curDef.Resolve(context).GetDefinition(); if (resolvedDef != null) { context = context.WithCurrentTypeDefinition(resolvedDef); var curMember = resolvedDef.Members.FirstOrDefault(m => m.Region.FileName == file.FileName && m.Region.Begin <= location && location < m.BodyRegion.End); if (curMember != null) { context = context.WithCurrentMember(curMember); } } } }
IUnresolvedTypeDefinition GetCurrentClass() { if (SD.Workbench.ActiveViewContent == null || SD.Workbench.ActiveViewContent.PrimaryFileName == null) { return(null); } IUnresolvedFile parseInfo = SD.ParserService.GetExistingUnresolvedFile(SD.Workbench.ActiveViewContent.PrimaryFileName); if (parseInfo != null) { IPositionable positionable = SD.Workbench.ActiveViewContent.GetService <IPositionable>(); if (positionable != null) { var c = parseInfo.GetInnermostTypeDefinition(positionable.Line, positionable.Column); if (c != null) { return(c); } } } return(null); }
/// <summary> /// Gets the type (potentially a nested type) defined at the specified location. /// Returns null if no type is defined at that location. /// </summary> public static IUnresolvedTypeDefinition GetInnermostTypeDefinition(this IUnresolvedFile file, int line, int column) { return(file.GetInnermostTypeDefinition(new TextLocation(line, column))); }
public IList <ICompletionItem> CreateElementList(XamlCompletionContext context, bool includeAbstract) { if (context.ParseInformation == null) { return(EmptyList <ICompletionItem> .Instance); } List <ICompletionItem> result = new List <ICompletionItem>(); AXmlElement last = context.ParentElement; ITextEditor editor = context.Editor; compilation = SD.ParserService.GetCompilationForFile(editor.FileName); IUnresolvedFile file = context.ParseInformation.UnresolvedFile; foreach (string item in XamlConst.GetAllowedItems(context)) { result.Add(new XamlCompletionItem(item)); } IType rt = null; if (last != null) { if (string.Equals(last.Prefix, context.XamlNamespacePrefix, StringComparison.OrdinalIgnoreCase)) { if (string.Equals(last.LocalName, "Members", StringComparison.OrdinalIgnoreCase)) { return(result); } if (string.Equals(last.LocalName, "Code", StringComparison.OrdinalIgnoreCase)) { return(result); } } // If we have an element that is not a property or an incomplete // definition => interpret element as a type. XamlResolver resolver = new XamlResolver(compilation); int dotIndex = last.LocalName.IndexOf(".", StringComparison.Ordinal) + 1; if (dotIndex < 1 || dotIndex == last.LocalName.Length) { rt = resolver.ResolveType(last.Namespace, last.LocalName.Trim('.')); string contentPropertyName = GetContentPropertyName(rt.GetDefinition()); // If the type has a content property specified, use its type for completion. if (!string.IsNullOrEmpty(contentPropertyName)) { IProperty p = rt.GetProperties(m => m.Name == contentPropertyName).FirstOrDefault(); if (p != null) { rt = p.ReturnType; } } } else { string typeName = last.LocalName.Substring(0, dotIndex - 1); string memberName = last.LocalName.Substring(dotIndex); rt = resolver.ResolveType(last.Namespace, typeName); IMember member = rt.GetMembers(m => m.Name == memberName).FirstOrDefault(); if (member != null) { rt = member.ReturnType; } } } bool parentAdded = false; var utd = file.GetInnermostTypeDefinition(editor.Caret.Location); ITypeDefinition currentTypeDef = null; if (utd != null) { currentTypeDef = utd.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)).GetDefinition(); } MemberLookup memberLookup = new MemberLookup(currentTypeDef, compilation.MainAssembly); IList <ITypeDefinition> possibleTypesInCollection = EmptyList <ITypeDefinition> .Instance; if (rt != null && Extensions.IsListType(rt)) { possibleTypesInCollection = rt.GetMethods(m => m.Parameters.Count == 1 && "Add".Equals(m.Name, StringComparison.Ordinal)) .Select(m => m.Parameters[0].Type.GetDefinition()) .Where(t => t != null) .ToList(); } var items = GetClassesFromContext(context); foreach (var ns in items) { foreach (ITypeDefinition td in ns.Value) { if (td.Kind != TypeKind.Class && (!includeAbstract || td.Kind != TypeKind.Interface)) { continue; } if (td.IsStatic || (!includeAbstract && td.IsAbstract) || td.IsDerivedFrom(KnownTypeCode.Attribute)) { continue; } if (td.Kind == TypeKind.Class && !td.GetConstructors().Any(m => memberLookup.IsAccessible(m, false))) { continue; } if (possibleTypesInCollection.Count > 0 && !possibleTypesInCollection.Any(td.IsDerivedFrom)) { continue; } string fullName = td.Name; if (!string.IsNullOrEmpty(ns.Key)) { fullName = ns.Key + ":" + fullName; } XamlCompletionItem item = new XamlCompletionItem(fullName, td); parentAdded = parentAdded || (last != null && item.Text == last.Name); result.Add(item); } } // TODO reimplement this if it is really necessary. // if (!parentAdded && last != null && !last.Name.Contains(".")) { // IClass itemClass = cu.CreateType(last.Namespace, last.LocalName.Trim('.')).GetUnderlyingClass(); // if (itemClass != null) // result.Add(new XamlCodeCompletionItem(itemClass, last.Prefix)); // } return(result); }
public override IUnresolvedTypeDefinition GetInnermostTypeDefinition(TextLocation location) { return(parsedFile.GetInnermostTypeDefinition(location)); }