/// <summary> /// Initializes a new instance of the <see cref="CSharpCompletionContext"/> class. /// </summary> /// <param name="document">The document, make sure the FileName property is set on the document.</param> /// <param name="offset">The offset.</param> /// <param name="projectContent">Content of the project.</param> /// <param name="usings">The usings.</param> /// <param name="variables">The variables</param> /// <param name="namespace">The namespace.</param> public CSharpCompletionContext(IDocument document, int offset, IProjectContent projectContent, string usings = null, string variables = null, string @namespace = null) { OriginalDocument = document; OriginalOffset = offset; OriginalUsings = usings; OriginalVariables = variables; OriginalNamespace = @namespace; //if the document is a c# script we have to soround the document with some code. Document = PrepareCompletionDocument(document, ref offset, usings, variables, @namespace); Offset = offset; var syntaxTree = new CSharpParser().Parse(Document, Document.FileName); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); ProjectContent = projectContent.AddOrUpdateFiles(unresolvedFile); //note: it's important that the project content is used that is returned after adding the unresolved file Compilation = ProjectContent.CreateCompilation(); var location = Document.GetLocation(Offset); Resolver = unresolvedFile.GetResolver(Compilation, location); TypeResolveContextAtCaret = unresolvedFile.GetTypeResolveContext(Compilation, location); CompletionContextProvider = new DefaultCompletionContextProvider(Document, unresolvedFile); }
protected ResolveResult Resolve(string code) { CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "code.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); SetUp(); CSharpParsedFile parsedFile = cu.ToTypeSystem(); project = project.UpdateProjectContent(null, parsedFile); compilation = project.CreateCompilation(); FindNodeVisitor fnv = new FindNodeVisitor(dollars[0], dollars[1]); cu.AcceptVisitor(fnv, null); Assert.IsNotNull(fnv.ResultNode, "Did not find DOM node at the specified location"); Debug.WriteLine(new string('=', 70)); Debug.WriteLine("Starting new resolver for " + fnv.ResultNode); CSharpAstResolver resolver = new CSharpAstResolver(compilation, cu, parsedFile); ResolveResult rr = resolver.Resolve(fnv.ResultNode); Assert.IsNotNull(rr, "ResolveResult is null - did something go wrong while navigating to the target node?"); Debug.WriteLine("ResolveResult is " + rr); return(rr); }
private void CompileAndResolve() { _unresolvedFile = SyntaxTree.ToTypeSystem(); _projectContent = _projectContent.AddOrUpdateFiles(_unresolvedFile); _compilation = _projectContent.CreateCompilation(); _resolver = new CSharpAstResolver(_compilation, SyntaxTree, _unresolvedFile); }
public Common.DomRegion ResolveTypeByName(string typeName, string typeMemberName) { if (Project == null) { return(Common.DomRegion.Empty); } var code = $"class dummy11111 {{ System.Type t = typeof({typeName}); }}"; var location = new ReadOnlyDocument(code).GetLocation(code.Length - 6); var syntaxTree = new CSharpParser().Parse(code, "dummy11111.cs"); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); Project = Project.AddOrUpdateFiles(unresolvedFile); var compilation = Project.CreateCompilation(); var result = ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location); var type = (result as TypeResolveResult).Type as DefaultResolvedTypeDefinition; if (type != null) { var asm = type.ParentAssembly; if (asm.UnresolvedAssembly is IUnresolvedAssembly) //referenced assembly { FileLocation document = new Reflector().ReconstructToFile(asm, type, memberName: typeMemberName); return(document.ToDomRegion().ToCommon()); } } return(Common.DomRegion.Empty); }
void Init(string program) { pc = new CSharpProjectContent(); pc = pc.SetAssemblyName("MyAssembly"); unresolvedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem(); pc = pc.AddOrUpdateFiles(unresolvedFile); pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib }); compilation = pc.CreateCompilation(); }
void Init(string program) { pc = new CSharpProjectContent(); pc = pc.SetAssemblyName("MyAssembly"); unresolvedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem(); pc = pc.AddOrUpdateFiles(unresolvedFile); pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib }); compilation = pc.CreateCompilation(); }
public virtual void SetUp() { SD.InitializeForUnitTests(); project = MockRepository.GenerateStrictMock<IProject>(); project.Stub(p => p.RootNamespace).Return("RootNamespace"); testProject = new NUnitTestProject(project); projectContent = new CSharpProjectContent().AddAssemblyReferences(NRefactoryHelper.Corlib, NRefactoryHelper.NUnitFramework); SD.Services.AddStrictMockService<IParserService>(); SD.ParserService.Stub(p => p.GetCompilation(project)).WhenCalled(m => m.ReturnValue = projectContent.CreateCompilation()); }
public void SetUp() { SD.InitializeForUnitTests(); SD.Services.AddService(typeof(IParserService), MockRepository.GenerateStrictMock <IParserService>()); project = MockRepository.GenerateStrictMock <IProject>(); projectContent = new CSharpProjectContent(); SD.ParserService .Stub(p => p.GetCompilation(project)) .WhenCalled(c => c.ReturnValue = projectContent.CreateCompilation()); }
public void SetUp() { SD.InitializeForUnitTests(); SD.Services.AddService(typeof(IParserService), MockRepository.GenerateStrictMock<IParserService>()); project = MockRepository.GenerateStrictMock<IProject>(); projectContent = new CSharpProjectContent(); SD.ParserService .Stub(p => p.GetCompilation(project)) .WhenCalled(c => c.ReturnValue = projectContent.CreateCompilation()); }
public ICompilation GetCompilation(IProjectContent project) { if (project == null) { throw new ArgumentNullException("project"); } if (!dictionary.ContainsKey(project)) { dictionary[project] = project.CreateCompilation(this); } return(dictionary[project]); }
private void AddOrUpdateFiles() { typeSystemCache.Clear(); var unresolvedFiles = new IUnresolvedFile[sourceFiles.Count]; Parallel.For(0, unresolvedFiles.Length, i => { var syntaxTree = sourceFiles[i].SyntaxTree; unresolvedFiles[i] = GetTypeSystem(syntaxTree); }); project = project.AddOrUpdateFiles(unresolvedFiles); compilation = project.CreateCompilation(); }
public void SetUp() { pc = new CSharpProjectContent(); pc = pc.SetAssemblyName("MyAssembly"); parsedFile = new CSharpParser().Parse(new StringReader(program), "program.cs").ToTypeSystem(); pc = pc.UpdateProjectContent(null, parsedFile); pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib }); compilation = pc.CreateCompilation(); baseClass = compilation.RootNamespace.GetTypeDefinition("Base", 1); nestedClass = baseClass.NestedTypes.Single(); derivedClass = compilation.RootNamespace.GetTypeDefinition("Derived", 2); systemClass = compilation.FindType("NS.System, MyAssembly").GetDefinition(); }
public void SetUp() { pc = new CSharpProjectContent(); pc = pc.SetAssemblyName("MyAssembly"); parsedFile = new CSharpParser().Parse(new StringReader(program), "program.cs").ToTypeSystem(); pc = pc.UpdateProjectContent(null, parsedFile); pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib }); compilation = pc.CreateCompilation(); baseClass = compilation.RootNamespace.GetTypeDefinition("Base", 1); nestedClass = baseClass.NestedTypes.Single(); derivedClass = compilation.RootNamespace.GetTypeDefinition("Derived", 2); systemClass = compilation.RootNamespace.GetChildNamespace("NS").GetTypeDefinition("System", 0); }
public void SetUp() { pc = new CSharpProjectContent(); pc = pc.SetAssemblyName("MyAssembly"); unresolvedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem(); pc = pc.AddOrUpdateFiles(unresolvedFile); pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib }); compilation = pc.CreateCompilation(); baseClass = compilation.RootNamespace.GetTypeDefinition("Base", 1); nestedClass = baseClass.NestedTypes.Single(); derivedClass = compilation.RootNamespace.GetTypeDefinition("Derived", 2); systemClass = compilation.RootNamespace.GetChildNamespace("NS").GetTypeDefinition("System", 0); }
IEnumerable <Common.ICompletionData> GetCSharpCompletionData(ReadOnlyDocument doc, string editorText, int offset, string fileName, bool isControlSpace = true) // not the best way to put in the whole string every time { if (editorText[offset] != '.') //we may be at the partially complete word { for (int i = offset - 1; i >= 0; i--) { if (SimpleCodeCompletion.Delimiters.Contains(editorText[i])) { offset = i + 1; break; } } } //test for C# completion var location = doc.GetLocation(offset); var syntaxTree = new CSharpParser().Parse(editorText, fileName); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); Project = Project.AddOrUpdateFiles(unresolvedFile); //note project should be reassigned/recreated every time we add asms or file //IProjectContent project = new CSharpProjectContent(); //project = project.AddAssemblyReferences(builtInLibs.Value); //project = project.AddOrUpdateFiles(unresolvedFile); //IProjectContent project = new CSharpProjectContent().AddAssemblyReferences(builtInLibs.Value).AddOrUpdateFiles(unresolvedFile); var completionContextProvider = new DefaultCompletionContextProvider(doc, unresolvedFile); var compilation = Project.CreateCompilation(); var resolver = unresolvedFile.GetResolver(compilation, location); var engine = new CSharpCompletionEngine(doc, completionContextProvider, new SimpleCompletionDataFactory(resolver), Project, resolver.CurrentTypeResolveContext); var data = engine.GetCompletionData(offset, isControlSpace); return(data.PrepareForDisplay().ToCommon()); }
protected ResolveResult ResolveAtLocation(string code) { CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "test.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(1, dollars.Length, "Expected 1 dollar signs marking the location"); SetUp(); CSharpParsedFile parsedFile = cu.ToTypeSystem(); project = project.UpdateProjectContent(null, parsedFile); compilation = project.CreateCompilation(); ResolveResult rr = Resolver.ResolveAtLocation.Resolve(compilation, parsedFile, cu, dollars[0]); return(rr); }
protected Tuple <CSharpAstResolver, AstNode> PrepareResolver(string code) { CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "code.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); SetUp(); CSharpParsedFile parsedFile = cu.ToTypeSystem(); project = project.UpdateProjectContent(null, parsedFile); compilation = project.CreateCompilation(); CSharpAstResolver resolver = new CSharpAstResolver(compilation, cu, parsedFile); return(Tuple.Create(resolver, FindNode(cu, dollars[0], dollars[1]))); }
protected ResolveResult ResolveAtLocation(string code) { SyntaxTree syntaxTree = SyntaxTree.Parse(code.Replace("$", ""), "test.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(1, dollars.Length, "Expected 1 dollar signs marking the location"); SetUp(); CSharpUnresolvedFile unresolvedFile = syntaxTree.ToTypeSystem(); project = project.AddOrUpdateFiles(unresolvedFile); compilation = project.CreateCompilation(); ResolveResult rr = Resolver.ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, dollars[0]); return(rr); }
protected Tuple <CSharpAstResolver, AstNode> PrepareResolver(string code) { SyntaxTree syntaxTree = new CSharpParser().Parse(code.Replace("$", ""), "code.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); SetUp(); CSharpUnresolvedFile unresolvedFile = syntaxTree.ToTypeSystem(); project = project.AddOrUpdateFiles(unresolvedFile); compilation = project.CreateCompilation(); CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile); return(Tuple.Create(resolver, FindNode(syntaxTree, dollars[0], dollars[1]))); }
ResolveResult ResolveFromPosition(string editorText, int offset, string fileName) { if (Project == null) { return(null); } var location = new ReadOnlyDocument(editorText).GetLocation(offset); var syntaxTree = new CSharpParser().Parse(editorText, fileName); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); Project = Project.AddOrUpdateFiles(unresolvedFile); var compilation = Project.CreateCompilation(); return(ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location)); }
/// <summary> /// Initializes a new instance of the <see cref="CSharpCompletionContext"/> class. /// </summary> /// <param name="document">The document, make sure the FileName property is set on the document.</param> /// <param name="offset">The offset.</param> /// <param name="projectContent">Content of the project.</param> /// <param name="usings">The usings.</param> public CSharpCompletionContext(IDocument document, int offset, IProjectContent projectContent, string usings = null) { OriginalDocument = document; OriginalOffset = offset; //if the document is a c# script we have to soround the document with some code. Document = PrepareCompletionDocument(document, ref offset, usings); Offset = offset; var syntaxTree = new CSharpParser().Parse(Document, Document.FileName); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); ProjectContent = projectContent.AddOrUpdateFiles(unresolvedFile); //note: it's important that the project content is used that is returned after adding the unresolved file Compilation = ProjectContent.CreateCompilation(); var location = Document.GetLocation(Offset); Resolver = unresolvedFile.GetResolver(Compilation, location); TypeResolveContextAtCaret = unresolvedFile.GetTypeResolveContext(Compilation, location); CompletionContextProvider = new DefaultCompletionContextProvider(Document, unresolvedFile); }
protected Tuple <CSharpAstResolver, AstNode> PrepareResolver(string code) { CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "code.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); SetUp(); CSharpParsedFile parsedFile = cu.ToTypeSystem(); project = project.UpdateProjectContent(null, parsedFile); compilation = project.CreateCompilation(); FindNodeVisitor fnv = new FindNodeVisitor(dollars[0], dollars[1]); cu.AcceptVisitor(fnv, null); Assert.IsNotNull(fnv.ResultNode, "Did not find DOM node at the specified location"); CSharpAstResolver resolver = new CSharpAstResolver(compilation, cu, parsedFile); return(Tuple.Create(resolver, fnv.ResultNode)); }
public async Task LoadTypesAsync() { if (OnlyCountLines) { return; } await Task.Factory.StartNew(() => { if (_projectContent == null) { return; } var ownCodeAssemblyNames = new HashSet <string>(_solution.Projects.Select(p => p._assemblyName)); foreach (var cSharpFile in _files.Where(f => f.FileExists)) { _compilation = _projectContent.CreateCompilation(_solution.Snapshot); var resolver = cSharpFile.CreateResolver(); var typeBuilder = new TypeSystemBuilder(resolver, _solution.Nodes, _solution.Edges, ownCodeAssemblyNames); cSharpFile.AcceptAstVisitor(typeBuilder); } }); ProgressPercentage = 50; }
public override IEnumerable<MemberReference> FindReferences (Project project, IProjectContent content, IEnumerable<FilePath> possibleFiles, IEnumerable<object> members) { if (project == null) throw new ArgumentNullException ("project", "Project not set."); if (content == null) throw new ArgumentNullException ("content", "Project content not set."); SetPossibleFiles (possibleFiles); SetSearchedMembers (members); var scopes = searchedMembers.Select (e => refFinder.GetSearchScopes (e as IEntity)); var compilation = TypeSystemService.GetCompilation (project); List<MemberReference> refs = new List<MemberReference> (); foreach (var opendoc in openDocuments) { foreach (var newRef in FindInDocument (opendoc.Item2)) { if (newRef == null || refs.Any (r => r.FileName == newRef.FileName && r.Region == newRef.Region)) continue; refs.Add (newRef); } } foreach (var file in files) { string text = Mono.TextEditor.Utils.TextFileUtility.ReadAllText (file); if (memberName != null && text.IndexOf (memberName, StringComparison.Ordinal) < 0 && (keywordName == null || text.IndexOf (keywordName, StringComparison.Ordinal) < 0)) continue; using (var editor = TextEditorData.CreateImmutable (text)) { editor.Document.FileName = file; var unit = new CSharpParser ().Parse (editor); if (unit == null) continue; var storedFile = content.GetFile (file); var parsedFile = storedFile as CSharpParsedFile; if (parsedFile == null && storedFile is ParsedDocumentDecorator) { parsedFile = ((ParsedDocumentDecorator)storedFile).ParsedFile as CSharpParsedFile; } if (parsedFile == null) { // for fallback purposes - should never happen. parsedFile = unit.ToTypeSystem (); content = content.UpdateProjectContent (content.GetFile (file), parsedFile); compilation = content.CreateCompilation (); } foreach (var scope in scopes) { refFinder.FindReferencesInFile ( scope, parsedFile, unit, compilation, (astNode, result) => { var newRef = GetReference (result, astNode, file, editor); if (newRef == null || refs.Any (r => r.FileName == newRef.FileName && r.Region == newRef.Region)) return; refs.Add (newRef); }, CancellationToken.None ); } } } return refs; }
public virtual void SetUp() { SD.InitializeForUnitTests(); project = MockRepository.GenerateStrictMock <IProject>(); project.Stub(p => p.RootNamespace).Return("RootNamespace"); testProject = new NUnitTestProject(project); projectContent = new CSharpProjectContent().AddAssemblyReferences(NRefactoryHelper.Corlib, NRefactoryHelper.NUnitFramework); SD.Services.AddStrictMockService <IParserService>(); SD.ParserService.Stub(p => p.GetCompilation(project)).WhenCalled(m => m.ReturnValue = projectContent.CreateCompilation()); }
public virtual void SetUp() { project = new CSharpProjectContent().AddAssemblyReferences(new [] { mscorlib, CecilLoaderTests.SystemCore }); compilation = project.CreateCompilation(); }
protected ITypeDefinition GetFirstTypeDefinition() { ICompilation compilation = projectContent.CreateCompilation(); return(compilation.MainAssembly.TopLevelTypeDefinitions.First()); }
public virtual void SetUp() { SD.InitializeForUnitTests(); SD.Services.AddStrictMockService <IParserService>(); project = MockRepository.GenerateStrictMock <IProject>(); projectContent = new CSharpProjectContent().AddAssemblyReferences(AssemblyLoader.Corlib); context = new ProjectEntityModelContext(project, ".cs"); assemblyModel = new AssemblyModel(context); SD.ParserService.Stub(p => p.GetCompilation(project)).WhenCalled(c => c.ReturnValue = projectContent.CreateCompilation()); }
private void CompileAndResolve() { _unresolvedFile = SyntaxTree.ToTypeSystem(); _projectContent = _projectContent.AddOrUpdateFiles(_unresolvedFile); _compilation = _projectContent.CreateCompilation(); _resolver = new CSharpAstResolver(_compilation, SyntaxTree, _unresolvedFile); }
public override IEnumerable <MemberReference> FindReferences(Project project, IProjectContent content, IEnumerable <FilePath> possibleFiles, IProgressMonitor monitor, IEnumerable <object> members) { if (content == null) { throw new ArgumentNullException("content", "Project content not set."); } SetPossibleFiles(possibleFiles); SetSearchedMembers(members); var scopes = searchedMembers.Select(e => e is IEntity ? refFinder.GetSearchScopes((IEntity)e) : refFinder.GetSearchScopes((INamespace)e)); var compilation = project != null?TypeSystemService.GetCompilation(project) : content.CreateCompilation(); List <MemberReference> refs = new List <MemberReference> (); foreach (var opendoc in openDocuments) { foreach (var newRef in FindInDocument(opendoc.Item2)) { if (newRef == null || refs.Any(r => r.FileName == newRef.FileName && r.Region == newRef.Region)) { continue; } refs.Add(newRef); } } foreach (var file in files) { if (monitor != null) { monitor.Step(1); } string text = Mono.TextEditor.Utils.TextFileUtility.ReadAllText(file); if (memberName != null && text.IndexOf(memberName, StringComparison.Ordinal) < 0 && (keywordName == null || text.IndexOf(keywordName, StringComparison.Ordinal) < 0)) { continue; } using (var editor = TextEditorData.CreateImmutable(text)) { editor.Document.FileName = file; var unit = new PlayScriptParser().Parse(editor); if (unit == null) { continue; } var storedFile = content.GetFile(file); var parsedFile = storedFile as CSharpUnresolvedFile; if (parsedFile == null && storedFile is ParsedDocumentDecorator) { parsedFile = ((ParsedDocumentDecorator)storedFile).ParsedFile as CSharpUnresolvedFile; } if (parsedFile == null) { // for fallback purposes - should never happen. parsedFile = unit.ToTypeSystem(); content = content.AddOrUpdateFiles(parsedFile); compilation = content.CreateCompilation(); } foreach (var scope in scopes) { refFinder.FindReferencesInFile( scope, parsedFile, unit, compilation, (astNode, result) => { var newRef = GetReference(project, result, astNode, unit, file, editor); if (newRef == null || refs.Any(r => r.FileName == newRef.FileName && r.Region == newRef.Region)) { return; } refs.Add(newRef); }, CancellationToken.None ); } } } return(refs); }