|
private UpdateProjectContent ( IEnumerable |
||
| oldFiles | IEnumerable |
|
| newFiles | IEnumerable |
|
| Résultat | IProjectContent | |
IEntity Lookup(string cref)
{
string program = @"using System;
using System.Collections.Generic;
/// <summary/>
class Test {
int @int;
void M(int a) {}
void Overloaded(int a) {}
void Overloaded(string a) {}
void Overloaded(ref int a) {}
public int this[int index] { get { return 0; } }
public static int operator +(Test a, int b) { return 0; }
public static implicit operator Test(int a) { return 0; }
public static implicit operator int(Test a) { return 0; }
}
interface IGeneric<A, B> {
void Test<T>(ref T[,] a);
}
class Impl<T> : IGeneric<List<string>[,], T> {
void IGeneric<List<string>[,], T>.Test<X>(ref X[,] a) {}
}";
var pc = new CSharpProjectContent().AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib });
var cu = new CSharpParser().Parse(new StringReader(program), "program.cs");
var compilation = pc.UpdateProjectContent(null, cu.ToTypeSystem()).CreateCompilation();
var typeDefinition = compilation.MainAssembly.TopLevelTypeDefinitions.Single();
IEntity entity = typeDefinition.Documentation.ResolveCref(cref);
Assert.IsNotNull(entity, "ResolveCref() returned null.");
return entity;
}
void Init(string program)
{
var pc = new CSharpProjectContent().AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib });
var cu = new CSharpParser().Parse(new StringReader(program), "program.cs");
compilation = pc.UpdateProjectContent(null, cu.ToTypeSystem()).CreateCompilation();
typeDefinition = compilation.MainAssembly.TopLevelTypeDefinitions.FirstOrDefault();
}
void FindReferencesButtonClick(object sender, EventArgs e)
{
if (csharpTreeView.SelectedNode == null)
return;
IProjectContent project = new CSharpProjectContent();
var parsedFile = compilationUnit.ToTypeSystem();
project = project.UpdateProjectContent(null, parsedFile);
project = project.AddAssemblyReferences(builtInLibs.Value);
ICompilation compilation = project.CreateCompilation();
CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
AstNode node = (AstNode)csharpTreeView.SelectedNode.Tag;
IEntity entity;
MemberResolveResult mrr = resolver.Resolve(node) as MemberResolveResult;
TypeResolveResult trr = resolver.Resolve(node) as TypeResolveResult;
if (mrr != null) {
entity = mrr.Member;
} else if (trr != null) {
entity = trr.Type.GetDefinition();
} else {
return;
}
FindReferences fr = new FindReferences();
int referenceCount = 0;
FoundReferenceCallback callback = delegate(AstNode matchNode, ResolveResult result) {
Debug.WriteLine(matchNode.StartLocation + " - " + matchNode + " - " + result);
referenceCount++;
};
var searchScopes = fr.GetSearchScopes(entity);
Debug.WriteLine("Find references to " + entity.ReflectionName);
fr.FindReferencesInFile(searchScopes, parsedFile, compilationUnit, compilation, callback, CancellationToken.None);
MessageBox.Show("Found " + referenceCount + " references to " + entity.FullName);
}
void ResolveButtonClick(object sender, EventArgs e)
{
IProjectContent project = new CSharpProjectContent();
var parsedFile = compilationUnit.ToTypeSystem();
project = project.UpdateProjectContent(null, parsedFile);
project = project.AddAssemblyReferences(builtInLibs.Value);
ICompilation compilation = project.CreateCompilation();
StoreInDictionaryNavigator navigator;
if (csharpTreeView.SelectedNode != null) {
navigator = new StoreInDictionaryNavigator((AstNode)csharpTreeView.SelectedNode.Tag);
} else {
navigator = new StoreInDictionaryNavigator();
}
CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
resolver.ApplyNavigator(navigator);
csharpTreeView.BeginUpdate();
ShowResolveResultsInTree(csharpTreeView.Nodes, navigator);
csharpTreeView.EndUpdate();
}
protected void Prepare(string source, bool minimizeNames = true, bool expectErrors = false)
{
IProjectContent project = new CSharpProjectContent();
var parser = new CSharpParser();
using (var rdr = new StringReader(source)) {
var pf = new CSharpParsedFile("File.cs");
var cu = parser.Parse(rdr, pf.FileName);
cu.AcceptVisitor(new TypeSystemConvertVisitor(pf));
project = project.UpdateProjectContent(null, pf);
}
project = project.AddAssemblyReferences(new[] { Common.Mscorlib });
var compilation = project.CreateCompilation();
errorReporter = new MockErrorReporter(!expectErrors);
Metadata = new MetadataImporter.ScriptSharpMetadataImporter(minimizeNames);
Metadata.Prepare(compilation.GetAllTypeDefinitions(), compilation.MainAssembly, errorReporter);
AllErrors = errorReporter.AllMessages.ToList().AsReadOnly();
AllErrorTexts = errorReporter.AllMessagesText.ToList().AsReadOnly();
if (expectErrors) {
AllErrorTexts.Should().NotBeEmpty("Compile should have generated errors");
}
else {
AllErrorTexts.Should().BeEmpty("Compile should not generate errors");
}
AllTypes = compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).ToDictionary(t => t.ReflectionName);
}
void ResolveButtonClick(object sender, EventArgs e)
{
IProjectContent project = new CSharpProjectContent();
var parsedFile = compilationUnit.ToTypeSystem();
project = project.UpdateProjectContent(null, parsedFile);
project = project.AddAssemblyReferences(builtInLibs.Value);
ICompilation compilation = project.CreateCompilation();
ResolveResult result;
if (csharpTreeView.SelectedNode != null) {
var selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag;
CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
result = resolver.Resolve(selectedNode);
// CSharpAstResolver.Resolve() never returns null
} else {
TextLocation location = GetTextLocation(csharpCodeTextBox, csharpCodeTextBox.SelectionStart);
result = ResolveAtLocation.Resolve(compilation, parsedFile, compilationUnit, location);
if (result == null) {
MessageBox.Show("Could not find a resolvable node at the caret location.");
return;
}
}
using (var dlg = new SemanticTreeDialog(result))
dlg.ShowDialog();
}
void HandleClicked (object sender, EventArgs e)
{
var parser = new CSharpParser ();
var unit = parser.Parse (textview1.Buffer.Text, "dummy.cs");
var parsedFile = unit.ToTypeSystem();
IProjectContent project = new CSharpProjectContent ();
project = project.UpdateProjectContent (null, parsedFile);
project = project.AddAssemblyReferences (builtInLibs.Value);
CSharpAstResolver resolver = new CSharpAstResolver(project.CreateCompilation (), unit, parsedFile);
ShowUnit (unit, resolver);
}
public override void VisitCompilationUnit(CompilationUnit unit)
{
IProjectContent project = new CSharpProjectContent();
_parsedFile = unit.ToTypeSystem();
project = project.UpdateProjectContent(null, _parsedFile);
project = project.AddAssemblyReferences(builtInLibs.Value);
_compilation = project.CreateCompilation();
_compilationUnit = unit;
_resolver = new CSharpAstResolver(_compilation, _compilationUnit, _parsedFile);
base.VisitCompilationUnit(unit);
}
public PreparedCompilation CreateCompilation(IEnumerable<ISourceFile> sourceFiles, IEnumerable<IAssemblyReference> references, IList<string> defineConstants)
{
IProjectContent project = new CSharpProjectContent();
var files = sourceFiles.Select(f => {
using (var rdr = f.Open()) {
var cu = CreateParser(defineConstants).Parse(rdr, f.FileName);
var expandResult = new QueryExpressionExpander().ExpandQueryExpressions(cu);
cu = (expandResult != null ? (CompilationUnit)expandResult.AstNode : cu);
var definedSymbols = DefinedSymbolsGatherer.Gather(cu, defineConstants);
return new PreparedCompilation.ParsedSourceFile(cu, new CSharpParsedFile(f.FileName, new UsingScope()), definedSymbols);
}
}).ToList();
foreach (var f in files) {
var tcv = new TypeSystemConvertVisitor(f.ParsedFile);
f.CompilationUnit.AcceptVisitor(tcv);
project = project.UpdateProjectContent(null, f.ParsedFile);
}
project = project.AddAssemblyReferences(references);
return new PreparedCompilation(project.CreateCompilation(), files);
}
