void HandleDocumentParsed(object sender, EventArgs e) { if (src != null) { src.Cancel(); } resolver = null; if (guiDocument != null && MonoDevelop.Core.PropertyService.Get("EnableSemanticHighlighting", true)) { var parsedDocument = guiDocument.ParsedDocument; if (parsedDocument != null) { unit = parsedDocument.GetAst <CompilationUnit> (); parsedFile = parsedDocument.ParsedFile as CSharpParsedFile; if (guiDocument.Project != null && guiDocument.IsCompileableInProject) { src = new CancellationTokenSource(); var cancellationToken = src.Token; System.Threading.Tasks.Task.Factory.StartNew(delegate { Thread.Sleep(100); compilation = guiDocument.Compilation; var newResolver = new CSharpAstResolver(compilation, unit, parsedFile); var visitor = new QuickTaskVisitor(newResolver, cancellationToken); unit.AcceptVisitor(visitor); if (!cancellationToken.IsCancellationRequested) { Gtk.Application.Invoke(delegate { if (cancellationToken.IsCancellationRequested) { return; } var editorData = guiDocument.Editor; if (editorData == null) { return; } resolver = newResolver; quickTasks = visitor.QuickTasks; OnTasksUpdated(EventArgs.Empty); var textEditor = editorData.Parent; if (textEditor != null) { var margin = textEditor.TextViewMargin; if (!parsedDocument.HasErrors) { highlightedSegmentCache.Clear(); margin.PurgeLayoutCache(); textEditor.QueueDraw(); } } }); } }, cancellationToken); } } } }
public TestRefactoringContext(IDocument document, TextLocation location, CSharpAstResolver resolver) : base(resolver, CancellationToken.None) { this.doc = document; this.location = location; this.UseExplicitTypes = UseExplict; this.FormattingOptions = FormattingOptionsFactory.CreateMono(); UseExplict = false; Services.AddService(typeof(NamingConventionService), new TestNameService()); }
public VariableReferenceNode Build(ControlFlowNode startNode, ISet <AstNode> references, ISet <Statement> refStatements, CSharpAstResolver resolver) { this.references = references; this.refStatements = refStatements; this.resolver = resolver; nodeDict = new Dictionary <ControlFlowNode, VariableReferenceNode> (); return(AddNode(startNode)); }
public RefactoringOptions(Document doc) { this.Document = doc; if (doc != null && doc.ParsedDocument != null) { Unit = doc.ParsedDocument.GetAst <CompilationUnit> (); resolver = CreateResolver(Unit); } }
public TypeSystemBuilder(CSharpAstResolver resolver, IDictionary <string, CSharpType> types, List <IInheritanceRelationship> edges, HashSet <string> ownCodeAssemblyNames) : base(resolver, types, edges, ownCodeAssemblyNames) { if (!types.ContainsKey("System.Object")) { types.Add("System.Object", new Class(false, "System.Object", false, 0, false)); } }
private void InitResolver(SyntaxTree syntaxTree) { if (this.lastFileName != syntaxTree.FileName) { this.lastFileName = syntaxTree.FileName; var unresolvedFile = syntaxTree.ToTypeSystem(); this.resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile); } }
public MethodCompiler(IMetadataImporter metadataImporter, INamer namer, IErrorReporter errorReporter, ICompilation compilation, CSharpAstResolver resolver, IRuntimeLibrary runtimeLibrary) { _metadataImporter = metadataImporter; _namer = namer; _errorReporter = errorReporter; _compilation = compilation; _resolver = resolver; _runtimeLibrary = runtimeLibrary; }
private void InitResolver(SyntaxTree syntaxTree) { if (lastFileName != syntaxTree.FileName || string.IsNullOrEmpty(syntaxTree.FileName)) { lastFileName = syntaxTree.FileName; var typeSystem = GetTypeSystem(syntaxTree); resolver = new CSharpAstResolver(compilation, syntaxTree, typeSystem); } }
static IEnumerable <IType> GetAllValidTypesFromInvocation(CSharpAstResolver resolver, InvocationExpression invoke, AstNode parameter) { int index = GetArgumentIndex(invoke.Arguments, parameter); if (index < 0) { yield break; } if (resolver.Resolve(invoke.Target) is MethodGroupResolveResult targetResult) { foreach (var method in targetResult.Methods) { if (index < method.Parameters.Count) { if (method.Parameters[index].IsParams) { if (method.Parameters[index].Type is ArrayType arrayType) { yield return(arrayType.ElementType); } } yield return(method.Parameters[index].Type); } } foreach (var extMethods in targetResult.GetExtensionMethods()) { foreach (var extMethod in extMethods) { IType[] inferredTypes; var m = extMethod; if (CSharpResolver.IsEligibleExtensionMethod(targetResult.TargetType, extMethod, true, out inferredTypes)) { if (inferredTypes != null) { m = extMethod.Specialize(new TypeParameterSubstitution(null, inferredTypes)); } } int correctedIndex = index + 1; if (correctedIndex < m.Parameters.Count) { if (m.Parameters[correctedIndex].IsParams) { if (m.Parameters[correctedIndex].Type is ArrayType arrayType) { yield return(arrayType.ElementType); } } yield return(m.Parameters[correctedIndex].Type); } } } } }
public DefiniteAssignmentAnalysis(Statement rootStatement, CSharpAstResolver resolver, CancellationToken cancellationToken) { if (rootStatement == null) { throw new ArgumentNullException("rootStatement"); } if (resolver == null) { throw new ArgumentNullException("resolver"); } this.resolver = resolver; visitor.analysis = this; DerivedControlFlowGraphBuilder cfgBuilder = new DerivedControlFlowGraphBuilder(); if (resolver.TypeResolveContext.Compilation.MainAssembly.UnresolvedAssembly is MinimalCorlib) { cfgBuilder.EvaluateOnlyPrimitiveConstants = true; } allNodes.AddRange(cfgBuilder.BuildControlFlowGraph(rootStatement, resolver, cancellationToken).Cast <DefiniteAssignmentNode>()); for (int i = 0; i < allNodes.Count; i++) { DefiniteAssignmentNode node = allNodes[i]; node.Index = i; // assign numbers to the nodes if (node.Type == ControlFlowNodeType.StartNode || node.Type == ControlFlowNodeType.BetweenStatements) { // Anonymous methods have separate control flow graphs, but we also need to analyze those. // Iterate backwards so that anonymous methods are inserted in the correct order for (AstNode child = node.NextStatement.LastChild; child != null; child = child.PrevSibling) { InsertAnonymousMethods(i + 1, child, cfgBuilder, cancellationToken); } } // Now register the node in the dictionaries: if (node.Type == ControlFlowNodeType.StartNode || node.Type == ControlFlowNodeType.BetweenStatements) { beginNodeDict.Add(node.NextStatement, node); } if (node.Type == ControlFlowNodeType.BetweenStatements || node.Type == ControlFlowNodeType.EndNode) { endNodeDict.Add(node.PreviousStatement, node); } if (node.Type == ControlFlowNodeType.LoopCondition) { conditionNodeDict.Add(node.NextStatement, node); } } // Verify that we created nodes for all statements: Debug.Assert(!rootStatement.DescendantsAndSelf.OfType <Statement>().Except(allNodes.Select(n => n.NextStatement)).Any()); // Verify that we put all nodes into the dictionaries: Debug.Assert(rootStatement.DescendantsAndSelf.OfType <Statement>().All(stmt => beginNodeDict.ContainsKey(stmt))); Debug.Assert(rootStatement.DescendantsAndSelf.OfType <Statement>().All(stmt => endNodeDict.ContainsKey(stmt))); this.analyzedRangeStart = 0; this.analyzedRangeEnd = allNodes.Count - 1; }
public MethodCompiler(IMetadataImporter metadataImporter, INamer namer, IErrorReporter errorReporter, ICompilation compilation, CSharpAstResolver resolver, IRuntimeLibrary runtimeLibrary, ISet <string> definedSymbols) { _metadataImporter = metadataImporter; _namer = namer; _errorReporter = errorReporter; _compilation = compilation; _resolver = resolver; _runtimeLibrary = runtimeLibrary; _definedSymbols = definedSymbols; }
public void Validate(CompilationUnit cu) { foreach (AstNode node in cu.DescendantsAndSelf.Except(resolvedNodes)) { if (!CSharpAstResolver.IsUnresolvableNode(node)) { Console.WriteLine("Forgot to resolve " + node); } } }
private void ShowSubtree(AstNode node, Int32 indent, CSharpAstResolver resolver) { ResolveResult result = resolver.Resolve(node); Console.WriteLine("{0} node type = {1}, value {2}, resolve result = {3}", new String(' ', indent), node.GetType().Name, Prepare(node.ToString()), GetResolveResultRepresentation(result)); foreach (AstNode child in node.Children) { ShowSubtree(child, indent + IndentDelta, resolver); } }
public static OmniSharpRefactoringContext GetContext(BufferParser bufferParser, Request request) { var q = bufferParser.ParsedContent(request.Buffer, request.FileName); var resolver = new CSharpAstResolver(q.Compilation, q.SyntaxTree, q.UnresolvedFile); var doc = new StringBuilderDocument(request.Buffer); var location = new TextLocation(request.Line, request.Column); var refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location); return(refactoringContext); }
public static bool TypeChangeResolvesCorrectly(BaseRefactoringContext ctx, ParameterDeclaration parameter, AstNode rootNode, IType type) { var resolver = ctx.GetResolverStateBefore(rootNode); resolver = resolver.AddVariable(new DefaultParameter(type, parameter.Name)); var astResolver = new CSharpAstResolver(resolver, rootNode, ctx.UnresolvedFile); var validator = new TypeChangeValidationNavigator(); astResolver.ApplyNavigator(validator, ctx.CancellationToken); return(!validator.FoundErrors); }
public static TestRefactoringContext Create(string content) { int idx = content.IndexOf("$"); if (idx >= 0) { content = content.Substring(0, idx) + content.Substring(idx + 1); } int idx1 = content.IndexOf("<-"); int idx2 = content.IndexOf("->"); int selectionStart = 0; int selectionEnd = 0; if (0 <= idx1 && idx1 < idx2) { content = content.Substring(0, idx2) + content.Substring(idx2 + 2); content = content.Substring(0, idx1) + content.Substring(idx1 + 2); selectionStart = idx1; selectionEnd = idx2 - 2; idx = selectionEnd; } var doc = new StringBuilderDocument(content); var parser = new CSharpParser(); var unit = parser.Parse(content, "program.cs"); if (parser.HasErrors) { parser.ErrorPrinter.Errors.ForEach(e => Console.WriteLine(e.Message)); } Assert.IsFalse(parser.HasErrors, "File contains parsing errors."); unit.Freeze(); var parsedFile = unit.ToTypeSystem(); IProjectContent pc = new CSharpProjectContent(); pc = pc.UpdateProjectContent(null, parsedFile); pc = pc.AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore }); var compilation = pc.CreateCompilation(); var resolver = new CSharpAstResolver(compilation, unit, parsedFile); TextLocation location = TextLocation.Empty; if (idx >= 0) { location = doc.GetLocation(idx); } return(new TestRefactoringContext(doc, location, resolver) { selectionStart = selectionStart, selectionEnd = selectionEnd }); }
static NodeResolved GetNextUnresolvedNode(AstNode tree, AstNode after, CSharpAstResolver resolver) { var nodes = GetResolvedNodes(tree, after, resolver); var node = nodes.FirstOrDefault(n => n.ResolveResult is UnknownIdentifierResolveResult); if (node == null) { node = nodes.FirstOrDefault(n => n.ResolveResult is UnknownMemberResolveResult); } return(node); }
public FixUsingsResponse FixUsings(Request request) { _fileName = request.FileName; string buffer = RemoveUsings(request.Buffer); buffer = SortUsings(buffer); buffer = AddLinqForQueryIfMissing(buffer); bool ambiguousResultsFound = false; bool usingsAdded = true; while (usingsAdded) { var content = _bufferParser.ParsedContent(buffer, _fileName); var tree = content.SyntaxTree; var resolver = new CSharpAstResolver(content.Compilation, content.SyntaxTree, content.UnresolvedFile); var unresolvedNodes = GetAllUnresolvedNodes(tree, resolver).Select(nr => GetNodeToAddUsing(nr)); usingsAdded = false; request.Buffer = buffer; var outerContext = OmniSharpRefactoringContext.GetContext(_bufferParser, request); using (var script = new OmniSharpScript(outerContext, _config)) { foreach (var unresolvedNode in unresolvedNodes) { _logger.Info(unresolvedNode); var requestForNode = CreateRequest(buffer, unresolvedNode); var innerContext = OmniSharpRefactoringContext.GetContext(_bufferParser, requestForNode); var addUsingAction = new AddUsingAction(); var actions = addUsingAction.GetActions(innerContext).Where(a => a.Description.StartsWith("using")).ToArray(); if (actions.Length == 1) { var a = actions[0]; _logger.Info("Adding " + a.Description); a.Run(script); usingsAdded = true; break; } ambiguousResultsFound |= actions.Length > 1; } } buffer = outerContext.Document.Text; } IEnumerable <QuickFix> ambiguous = Enumerable.Empty <QuickFix>(); if (ambiguousResultsFound) { ambiguous = GetAmbiguousNodes(buffer, request.FileName); } return(new FixUsingsResponse(buffer, ambiguous)); }
static IEnumerable <NodeResolved> GetAllUnresolvedNodes(AstNode tree, CSharpAstResolver resolver) { var nodes = tree.Descendants.OrderBy(n => n.StartLocation).Select(n => new NodeResolved { Node = n, ResolveResult = resolver.Resolve(n) }); return(nodes.Where(n => n.ResolveResult is UnknownIdentifierResolveResult || n.ResolveResult is UnknownMemberResolveResult)); }
public SDRefactoringContext(ITextSource textSource, CSharpAstResolver resolver, TextLocation location, int selectionStart, int selectionLength, CancellationToken cancellationToken) : base(resolver, cancellationToken) { this.resolver = resolver; this.textSource = textSource; this.document = textSource as IDocument; this.selectionStart = selectionStart; this.selectionLength = selectionLength; this.location = location; InitializeServices(); }
public VariableReferenceNode Build(Statement statement, ISet <AstNode> references, ISet <Statement> refStatements, CSharpAstResolver resolver, CancellationToken cancellationToken = default(CancellationToken)) { var cfg = cfgBuilder.BuildControlFlowGraph(statement, resolver, cancellationToken); if (cfg.Count == 0) { return(new VariableReferenceNode()); } return(cfgVrNodeBuilder.Build(cfg [0], references, refStatements, resolver)); }
public IList <ControlFlowNode> BuildControlFlowGraph(Statement statement, CSharpAstResolver resolver, CancellationToken cancellationToken = default(CancellationToken)) { if (statement == null) { throw new ArgumentNullException("statement"); } if (resolver == null) { throw new ArgumentNullException("resolver"); } return(BuildControlFlowGraph(statement, resolver.Resolve, resolver.TypeResolveContext, cancellationToken)); }
public SDRefactoringContext(ITextEditor editor, CSharpAstResolver resolver, TextLocation location, CancellationToken cancellationToken = default(CancellationToken)) : base(resolver, cancellationToken) { this.resolver = resolver; this.editor = editor; this.textSource = editor.Document; this.document = editor.Document; this.selectionStart = editor.SelectionStart; this.selectionLength = editor.SelectionLength; this.location = location; InitializeServices(); }
/// <summary> /// Returns a full C# syntax tree resolver which is shared between semantic highlighting, source analysis and refactoring. /// For code analysis tasks this should be used instead of generating an own resolver. Only exception is if a local resolving is done using a /// resolve navigator. /// Note: The shared resolver is fully resolved. /// </summary> public static TaskWrapper GetSharedResolver(this Document document) { var parsedDocument = document.ParsedDocument; if (parsedDocument == null) { return(null); } var unit = parsedDocument.GetAst <SyntaxTree> (); var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile; if (unit == null || parsedFile == null) { return(null); } var compilation = document.Compilation; var resolverAnnotation = document.Annotation <ResolverAnnotation> (); if (resolverAnnotation != null) { if (resolverAnnotation.ParsedFile == parsedFile) { return(resolverAnnotation.Task); } document.RemoveAnnotations <ResolverAnnotation> (); } sharedTokenSource.Cancel(); sharedTokenSource = new CancellationTokenSource(); var token = sharedTokenSource.Token; var resolveTask = Task.Factory.StartNew(delegate { try { using (var timer = ResolveCounter.BeginTiming()) { var result = new CSharpAstResolver(compilation, unit, parsedFile); result.ApplyNavigator(new ConstantModeResolveVisitorNavigator(ResolveVisitorNavigationMode.Resolve, null), token); return(result); } } catch (OperationCanceledException) { return(null); } catch (Exception e) { LoggingService.LogError("Error while creating the resolver.", e); return(null); } }, token); var wrapper = new TaskWrapper(resolveTask); document.AddAnnotation(new ResolverAnnotation { Task = wrapper, ParsedFile = parsedFile }); return(wrapper); }
public void ResolveTypeWithUnknownAttributes() { const String source = "namespace ns\r\n" + "{\r\n" + " public enum EE {v1 = 13, v2 = 666}\r\n" + " [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.Property, AllowMultiple = true)]\r\n" + " public class AttrA : System.Attribute\r\n" + " {\r\n" + " }\r\n" + " [System.AttributeUsage(System.AttributeTargets.Method)]\r\n" + " public class AttrB : System.Attribute\r\n" + " {\r\n" + " public AttrB(int i, string s, EE e) {}\r\n" + " }\r\n" + " public class SomeClass\r\n" + " {\r\n" + " [AttrA]\r\n" + " [AttrB(666, \"iddqd\", EE.v1)]\r\n" + " [AttrC]\r\n" + " public void M()\r\n" + " { }\r\n" + " }\r\n" + "}"; CSharpParser parser = new CSharpParser(); SyntaxTree syntaxTree = parser.Parse(source); syntaxTree.FileName = "example.cs"; CSharpUnresolvedFile unresolvedTypeSystem = syntaxTree.ToTypeSystem(); IProjectContent content = new CSharpProjectContent(); content = content.AddOrUpdateFiles(unresolvedTypeSystem); CecilLoader loader = new CecilLoader(); AssemblyDefinition mscorlibAssemblyDefinition = AssemblyDefinition.ReadAssembly(typeof(Object).Assembly.Location); IUnresolvedAssembly mscorlibAssembly = loader.LoadAssembly(mscorlibAssemblyDefinition); content = content.AddAssemblyReferences(mscorlibAssembly); ICompilation compilation = content.CreateCompilation(); CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree); MethodDeclaration method = syntaxTree.Descendants.OfType <MethodDeclaration>().First(m => m.Name == "M"); ResolveResult result = resolver.Resolve(method); MemberResolveResult memberResult = (MemberResolveResult)result; IMember member = memberResult.Member; foreach (IAttribute attribute in member.Attributes) { Console.WriteLine("attribute.AttributeType = {0}, attribute.AttributeType.Kind = {1}", attribute.AttributeType.FullName, attribute.AttributeType.Kind); Console.WriteLine("attribute.PositionalArguments.Count = {0}", attribute.PositionalArguments.Count); ProcessPositionalArgs(attribute.PositionalArguments); Console.WriteLine("attribute.NamedArguments.Count = {0}", attribute.NamedArguments.Count); Console.WriteLine(); } }
public override TooltipItem GetItem(Mono.TextEditor.TextEditor editor, int offset) { var doc = IdeApp.Workbench.ActiveDocument; if (doc == null || doc.ParsedDocument == null) { return(null); } var unit = doc.ParsedDocument.GetAst <SyntaxTree> (); if (unit == null) { return(null); } var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile; if (file == null) { return(null); } ResolveResult result; AstNode node; var loc = editor.OffsetToLocation(offset); if (!doc.TryResolveAt(loc, out result, out node)) { if (node is CSharpTokenNode) { int startOffset2 = editor.LocationToOffset(node.StartLocation); int endOffset2 = editor.LocationToOffset(node.EndLocation); return(new TooltipItem(new ToolTipData(unit, result, node, null), startOffset2, endOffset2 - startOffset2)); } return(null); } if (node == lastNode) { return(lastResult); } var resolver = new CSharpAstResolver(doc.Compilation, unit, file); resolver.ApplyNavigator(new NodeListResolveVisitorNavigator(node), CancellationToken.None); var hoverNode = node.GetNodeAt(loc) ?? node; int startOffset = editor.LocationToOffset(hoverNode.StartLocation); int endOffset = editor.LocationToOffset(hoverNode.EndLocation); return(lastResult = new TooltipItem(new ToolTipData(unit, result, node, resolver), startOffset, endOffset - startOffset)); }
public override void DoGlobalOperationOn(IEntity entity, Action <RefactoringContext, Script, AstNode> callback, string operationName = null) { using (var monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(operationName ?? GettextCatalog.GetString("Performing refactoring task..."), null)) { var col = ReferenceFinder.FindReferences(entity, true, monitor); string oldFileName = null; MDRefactoringContext ctx = null; MDRefactoringScript script = null; TextEditorData data = null; bool hadBom = false; System.Text.Encoding encoding = null; bool isOpen = true; foreach (var r in col) { var memberRef = r as CSharpReferenceFinder.CSharpMemberReference; if (memberRef == null) { continue; } if (oldFileName != memberRef.FileName) { if (oldFileName != null && !isOpen) { script.Dispose(); Mono.TextEditor.Utils.TextFileUtility.WriteText(oldFileName, data.Text, encoding, hadBom); } data = TextFileProvider.Instance.GetTextEditorData(memberRef.FileName, out hadBom, out encoding, out isOpen); var project = memberRef.Project; ParsedDocument parsedDocument; using (var reader = new StreamReader(data.OpenStream())) parsedDocument = new MonoDevelop.CSharp.Parser.TypeSystemParser().Parse(true, memberRef.FileName, reader, project); var resolver = new CSharpAstResolver(TypeSystemService.GetCompilation(project), memberRef.SyntaxTree, parsedDocument.ParsedFile as CSharpUnresolvedFile); ctx = new MDRefactoringContext(project as DotNetProject, data, parsedDocument, resolver, memberRef.AstNode.StartLocation, this.context.CancellationToken); script = new MDRefactoringScript(ctx, FormattingOptions); oldFileName = memberRef.FileName; } callback(ctx, script, memberRef.AstNode); } if (oldFileName != null && !isOpen) { script.Dispose(); Mono.TextEditor.Utils.TextFileUtility.WriteText(oldFileName, data.Text, encoding, hadBom); } } }
internal static StubbedRefactoringContext Create(SyntaxTree tree, bool supportsVersion5 = true) { IProjectContent pc = new CSharpProjectContent(); pc = pc.AddAssemblyReferences(CecilLoaderTests.Mscorlib); pc = pc.AddOrUpdateFiles(new[] { tree.ToTypeSystem() }); var compilation = pc.CreateCompilation(); var resolver = new CSharpAstResolver(compilation, tree); return(new StubbedRefactoringContext(resolver, supportsVersion5)); }
public void Run() { using (new Timer("Finding referenced entities... ")) { foreach (var file in solution.AllFiles) { var navigator = new FindReferencedEntities( delegate(AstNode node, IEntity entity) { if (node == null) { throw new ArgumentNullException("node"); } if (entity == null) { throw new ArgumentNullException("entity"); } if (!IgnoreEntity(entity)) { HashSet <AstNode> list; if (!referenceDict.TryGetValue(entity, out list)) { list = new HashSet <AstNode>(); referenceDict.Add(entity, list); } list.Add(node); } } ); var resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile); resolver.ApplyNavigator(navigator); } } Console.WriteLine("For each entity, find all references..."); Stopwatch w = Stopwatch.StartNew(); foreach (var project in solution.Projects) { foreach (var type in project.Compilation.MainAssembly.GetAllTypeDefinitions()) { TestFindReferences(type); foreach (IMember m in type.Members) { TestFindReferences(m); } Console.Write('.'); } } w.Stop(); Console.WriteLine("FindReferencesConsistencyCheck is done ({0}).", w.Elapsed); PrintTimingsPerEntityType(); }
public ResolveResult GetLanguageItem(MonoDevelop.Ide.Gui.Document doc, int offset, string expression) { if (offset < 0) { return(null); } var parsedDocument = doc.ParsedDocument; if (parsedDocument == null) { return(null); } var data = doc.Editor; var loc = data.OffsetToLocation(offset); var unit = parsedDocument.GetAst <SyntaxTree> (); var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile; if (unit == null || parsedFile == null) { return(null); } var node = unit.GetNodeAt(loc); if (node == null) { return(null); } var resolver = new CSharpAstResolver(doc.Compilation, unit, parsedFile); resolver.ApplyNavigator(new NodeListResolveVisitorNavigator(node), CancellationToken.None); var state = resolver.GetResolverStateBefore(node, CancellationToken.None); var list = new List <IType> (); int indexOf = expression.IndexOf('`'); if (indexOf != -1) { var intType = new PrimitiveType("int").ToTypeReference().Resolve(doc.Compilation); var num = expression.Substring(indexOf + 1); int number = int.Parse(num); for (int i = 0; i < number; i++) { list.Add(intType); } expression = expression.Remove(indexOf); } return(state.LookupSimpleNameOrTypeName(expression, list, NameLookupMode.Expression)); }