async Task LoadExceptionList()
{
classes.Add("System.Exception");
try {
Microsoft.CodeAnalysis.Compilation compilation = null;
Microsoft.CodeAnalysis.ProjectId dummyProjectId = null;
if (IdeApp.ProjectOperations.CurrentSelectedProject != null)
{
compilation = await TypeSystemService.GetCompilationAsync(IdeApp.ProjectOperations.CurrentSelectedProject);
}
if (compilation == null)
{
//no need to unload this assembly context, it's not cached.
dummyProjectId = Microsoft.CodeAnalysis.ProjectId.CreateNewId("GetExceptionsProject");
compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("GetExceptions")
.AddReferences(MetadataReferenceCache.LoadReference(dummyProjectId, System.Reflection.Assembly.GetAssembly(typeof(object)).Location)) //corlib
.AddReferences(MetadataReferenceCache.LoadReference(dummyProjectId, System.Reflection.Assembly.GetAssembly(typeof(Uri)).Location)); //System.dll
}
var exceptionClass = compilation.GetTypeByMetadataName("System.Exception");
foreach (var t in compilation.GlobalNamespace.GetAllTypes().Where((arg) => arg.IsDerivedFromClass(exceptionClass)))
{
classes.Add(t.GetFullMetadataName());
}
if (dummyProjectId != null)
{
MetadataReferenceCache.RemoveReferences(dummyProjectId);
}
} catch (Exception e) {
LoggingService.LogError("Failed to obtain exceptions list in breakpoint dialog.", e);
}
await Runtime.RunInMainThread(() => {
entryExceptionType.SetCodeCompletionList(classes.ToList());
});
}
public override async System.Threading.Tasks.Task <SourceCodeLocation> GetSourceCodeLocationAsync(MonoDevelop.Projects.Project project, string fixtureTypeNamespace, string fixtureTypeName, string testName, System.Threading.CancellationToken cancellationToken)
{
var ctx = await TypeSystemService.GetCompilationAsync(project, cancellationToken).ConfigureAwait(false);
var cls = ctx?.Assembly?.GetTypeByMetadataName(string.IsNullOrEmpty(fixtureTypeNamespace) ? fixtureTypeName : fixtureTypeNamespace + "." + fixtureTypeName);
if (cls == null)
{
return(null);
}
if (cls.Name != testName)
{
foreach (var met in cls.GetMembers(testName).OfType <IMethodSymbol> ())
{
var loc = met.Locations.FirstOrDefault(l => l.IsInSource);
return(ConvertToSourceCodeLocation(loc));
}
int idx = testName != null?testName.IndexOf('(') : -1;
if (idx > 0)
{
testName = testName.Substring(0, idx);
foreach (var met in cls.GetMembers(testName).OfType <IMethodSymbol> ())
{
var loc = met.Locations.FirstOrDefault(l => l.IsInSource);
return(ConvertToSourceCodeLocation(loc));
}
}
}
var classLoc = cls.Locations.FirstOrDefault(l => l.IsInSource);
return(ConvertToSourceCodeLocation(classLoc));
}
void LoadExceptionList()
{
classes.Add("System.Exception");
if (IdeApp.ProjectOperations.CurrentSelectedProject != null)
{
var compilation = TypeSystemService.GetCompilationAsync(IdeApp.ProjectOperations.CurrentSelectedProject).Result;
var exceptionClass = compilation.GetTypeByMetadataName("System.Exception");
foreach (var t in compilation.GlobalNamespace.GetAllTypes().Where((arg) => arg.IsDerivedFromClass(exceptionClass)))
{
classes.Add(t.GetFullMetadataName());
}
}
else
{
//no need to unload this assembly context, it's not cached.
var dummyProjectId = Microsoft.CodeAnalysis.ProjectId.CreateNewId("GetExceptionsProject");
var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("GetExceptions")
.AddReferences(MetadataReferenceCache.LoadReference(dummyProjectId, System.Reflection.Assembly.GetAssembly(typeof(object)).Location)) //corlib
.AddReferences(MetadataReferenceCache.LoadReference(dummyProjectId, System.Reflection.Assembly.GetAssembly(typeof(Uri)).Location)); //System.dll
var exceptionClass = compilation.GetTypeByMetadataName("System.Exception");
foreach (var t in compilation.GlobalNamespace.GetAllTypes().Where((arg) => arg.IsDerivedFromClass(exceptionClass)))
{
classes.Add(t.GetFullMetadataName());
}
MetadataReferenceCache.RemoveReferences(dummyProjectId);
}
entryExceptionType.SetCodeCompletionList(classes.ToList());
}
MetadataReference GetProjectReference(AssemblyName parsed)
{
if (project == null)
{
return(null);
}
var dllName = parsed.Name + ".dll";
foreach (var reference in project.References)
{
if (reference.ReferenceType == ReferenceType.Package || reference.ReferenceType == ReferenceType.Assembly)
{
foreach (string refPath in reference.GetReferencedFileNames(null))
{
if (Path.GetFileName(refPath) == dllName)
{
return(LoadMetadataReference(refPath));
}
}
}
else
if (reference.ReferenceType == ReferenceType.Project && parsed.Name == reference.Reference)
{
var p = reference.ResolveProject(project.ParentSolution) as DotNetProject;
if (p == null)
{
continue;
}
return(TypeSystemService.GetCompilationAsync(p).Result.ToMetadataReference());
}
}
return(null);
}
IEnumerable <MetadataReference> GetReferencedAssemblies()
{
var references = new HashSet <MetadataReference> ();
if (project != null)
{
var task = TypeSystemService.GetCompilationAsync(project);
if (task.Result != null)
{
references.Add(task.Result.ToMetadataReference());
}
}
if (doc != null)
{
foreach (var asm in doc.Info.Assemblies.Select(a => a.Name).Select(name => GetReferencedAssembly(name)))
{
references.Add(asm);
}
}
foreach (var asm in GetRegisteredAssemblies().Select(name => GetReferencedAssembly(name)))
{
references.Add(asm);
}
references.Remove(null);
return(references);
}
public static void BuildChildNodes(ITreeBuilder builder, Project project)
{
if (project is DotNetProject)
{
builder.AddChild(((DotNetProject)project).References);
}
bool publicOnly = builder.Options ["PublicApiOnly"];
var dom = TypeSystemService.GetCompilationAsync(project).Result;
if (dom == null)
{
return;
}
bool nestedNamespaces = builder.Options ["NestedNamespaces"];
HashSet <string> addedNames = new HashSet <string> ();
foreach (var ns in dom.Assembly.GlobalNamespace.GetNamespaceMembers())
{
if (nestedNamespaces)
{
if (!addedNames.Contains(ns.Name))
{
builder.AddChild(new ProjectNamespaceData(project, ns));
addedNames.Add(ns.Name);
}
}
else
{
FillNamespaces(builder, project, ns);
}
}
builder.AddChildren(dom.Assembly.GlobalNamespace.GetTypeMembers()
.Where(type => !publicOnly || type.DeclaredAccessibility == Accessibility.Public)
.Select(type => new ClassData(project, type)));
}
public TypeDataProvider(MonoDevelop.Projects.DotNetProject project)
{
TypeNamesList = new List <string> ();
var ctx = TypeSystemService.GetCompilationAsync(project).Result;
TypesList = new List <INamedTypeSymbol> (ctx.GetAllTypesInMainAssembly());
foreach (var typeDef in TypesList)
{
TypeNamesList.Add(Ambience.EscapeText(typeDef.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)));
}
}
protected override SourceCodeLocation GetSourceCodeLocation(string fixtureTypeNamespace, string fixtureTypeName, string methodName)
{
if (string.IsNullOrEmpty(fixtureTypeName) || string.IsNullOrEmpty(fixtureTypeName))
{
return(null);
}
var csc = new CancellationTokenSource();
var task = TypeSystemService.GetCompilationAsync(project, csc.Token);
task.Wait(2000);
if (!task.IsCompleted)
{
csc.Cancel();
return(null);
}
var ctx = task.Result;
var cls = ctx?.Assembly?.GetTypeByMetadataName(string.IsNullOrEmpty(fixtureTypeNamespace) ? fixtureTypeName : fixtureTypeNamespace + "." + fixtureTypeName);
if (cls == null)
{
return(null);
}
if (cls.Name != methodName)
{
foreach (var met in cls.GetMembers().OfType <IMethodSymbol> ())
{
if (met.Name == methodName)
{
var loc = met.Locations.FirstOrDefault(l => l.IsInSource);
return(ConvertToSourceCodeLocation(loc));
}
}
int idx = methodName != null?methodName.IndexOf('(') : -1;
if (idx > 0)
{
methodName = methodName.Substring(0, idx);
foreach (var met in cls.GetMembers().OfType <IMethodSymbol> ())
{
if (met.Name == methodName)
{
var loc = met.Locations.FirstOrDefault(l => l.IsInSource);
return(ConvertToSourceCodeLocation(loc));
}
}
}
}
var classLoc = cls.Locations.FirstOrDefault(l => l.IsInSource);
return(ConvertToSourceCodeLocation(classLoc));
}
async Task <INamedTypeSymbol> FindController(MonoDevelop.Projects.Project project, string name)
{
var compilation = await TypeSystemService.GetCompilationAsync(project);
if (compilation == null)
{
return(null);
}
return(compilation.GetAllTypesInMainAssembly()
.FirstOrDefault(symbol => symbol.Name == name + "Controller"));
}
public async Task TestLoadingSolution()
{
string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln");
var sol = (Projects.Solution) await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
await TypeSystemServiceTestExtensions.LoadSolution(sol);
var compilation = await TypeSystemService.GetCompilationAsync(sol.GetAllProjects().First());
var programType = compilation.GetTypeByMetadataName("ConsoleProject.Program");
Assert.IsNotNull(programType);
}
public Compilation GetParserContext()
{
System.Threading.Tasks.Task <Compilation> task;
do
{
task = TypeSystemService.GetCompilationAsync(Project);
task.Wait(500);
} while (!task.IsCompleted);
var dom = task.Result;
if (dom != null && needsUpdate)
{
needsUpdate = false;
}
return(dom);
}
/// <summary>
/// Adds the dependency to the project and returns true if the dependency was added to the project
/// </summary>
protected sealed override async Task <bool> OnAddToProject(CancellationToken token)
{
int tryCount = 1;
bool keepTrying = true;
while (keepTrying)
{
try {
if (tryCount > 1)
{
LoggingService.LogInfo("Retrying to add code dependency...");
}
else
{
LoggingService.LogInfo("Adding code dependency '{0}' to '{1}'...", this, this.Service.Project.Name);
}
this.compilation = await TypeSystemService.GetCompilationAsync(this.Service.Project).ConfigureAwait(false);
if (this.compilation == null)
{
LoggingService.LogInternalError("Could not get compilation object.", null);
return(false);
}
this.InitLookupTypes(token, this.lookupTypes.Keys.ToArray());
var result = await Runtime.RunInMainThread <bool> (
() => this.AddCodeToProject (token)
);
LoggingService.LogInfo(result ? "Code dependency added." : "Code dependency was not added.");
return(result);
} catch (SolutionVersionMismatchException) {
tryCount++;
}
keepTrying = tryCount <= 3;
}
return(false);
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
Project project = (Project)dataObject;
bool publicOnly = Widget.PublicApiOnly;
var dom = TypeSystemService.GetCompilationAsync(project).Result;
if (dom == null)
{
return;
}
bool nestedNamespaces = builder.Options ["NestedNamespaces"];
HashSet <string> addedNames = new HashSet <string> ();
foreach (var ns in dom.Assembly.GlobalNamespace.GetNamespaceMembers())
{
FillNamespaces(builder, project, ns);
}
builder.AddChildren(dom.Assembly.GlobalNamespace.GetTypeMembers()
.Where(type => !publicOnly || type.DeclaredAccessibility == Microsoft.CodeAnalysis.Accessibility.Public));
}
async Task <IEnumerable <MetadataReference> > GetReferencedAssemblies(CancellationToken token)
{
var references = new HashSet <MetadataReference> ();
if (project != null)
{
var result = await TypeSystemService.GetCompilationAsync(project, token);
if (result != null)
{
references.Add(result.ToMetadataReference());
}
}
var tasks = new List <Task <MetadataReference> > ();
if (doc != null)
{
foreach (var t in doc.Info.Assemblies.Select(a => a.Name).Select(name => GetReferencedAssembly(name, token)))
{
tasks.Add(t);
}
}
foreach (var t in GetRegisteredAssemblies().Select(name => GetReferencedAssembly(name, token)))
{
tasks.Add(t);
}
MetadataReference[] assemblies = await Task.WhenAll(tasks);
foreach (var asm in assemblies)
{
references.Add(asm);
}
references.Remove(null);
return(references);
}
/// <summary>
/// Removes the dependency from the project and returns true if the dependency was removed
/// </summary>
protected sealed override async Task <bool> OnRemoveFromProject(CancellationToken token)
{
int tryCount = 1;
bool keepTrying = true;
while (keepTrying)
{
try {
if (tryCount > 1)
{
LoggingService.LogInfo("Retrying to remove code dependency...");
}
else
{
LoggingService.LogInfo("Removing code dependency '{0}' from '{1}'...", this, this.Service.Project.Name);
}
var compilation = await TypeSystemService.GetCompilationAsync(this.Service.Project).ConfigureAwait(false);
if (compilation == null)
{
LoggingService.LogInternalError("Could not get compilation object.", null);
return(false);
}
this.InitLookupTypes(compilation, token, this.lookupTypes.Keys.ToArray());
var result = await this.RemoveCodeFromProject(token).ConfigureAwait(false);
LoggingService.LogInfo(result ? "Code dependency removed." : "Code dependency was not removed.");
return(result);
} catch (SolutionVersionMismatchException) {
tryCount++;
}
keepTrying = tryCount <= 3;
}
return(false);
}
void FillClasses()
{
try {
var ctx = TypeSystemService.GetCompilationAsync(project).Result;
if (ctx == null)
{
// Project not found in parser database
return;
}
foreach (var c in ctx.Assembly.GlobalNamespace.GetTypeMembers())
{
foreach (var m in c.GetMembers().OfType <IMethodSymbol> ())
{
if (m.IsStatic && m.Name == "Main")
{
classListStore.AppendValues(c.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat));
}
}
}
classListFilled = true;
} catch (InvalidOperationException) {
// Project not found in parser database
}
}
public async Task <List <ClassDefinition> > ProcessAsync(MonoDevelop.Projects.Project project, IProgress <TreeBuilderProgress> progress = null)
{
var classes = new Dictionary <ITypeSymbol, ClassDefinition>();
var compilation = await TypeSystemService.GetCompilationAsync(project);
var types = compilation.GetAllTypesInMainAssembly();
progress?.Report(new TreeBuilderProgress {
totalClasses = types.Count()
});
for (int i = 0; i < types.Count(); i++)
{
var type = types.ElementAt(i);
var definition = GetValueOrCreate(type, classes);
if (type.IsAbstract && definition.ClassType == ClassType.Class)
{
definition.ClassType = ClassType.Abstract;
}
foreach (var iface in type.Interfaces)
{
var interfaceDefinition = GetValueOrCreate(iface, classes);
interfaceDefinition.ClassType = ClassType.Interface;
definition.Interfaces.Add(interfaceDefinition);
}
foreach (var baseClass in type.GetAllBaseClasses())
{
if (!baseClass.IsDefinedInSource())
{
continue;
}
var baseDefinition = GetValueOrCreate(baseClass, classes);
definition.BaseClasses.Add(baseDefinition);
}
HashSet <ClassDefinition> dependencies = new HashSet <ClassDefinition>();
var syntaxDeclarations = type.GetDeclarations();
foreach (var declaration in syntaxDeclarations)
{
var semanticModel = compilation.GetSemanticModel(declaration.SyntaxTree);
var descendants = declaration.GetSyntax().DescendantNodes();
foreach (var descendant in descendants)
{
ITypeSymbol usedType = semanticModel.GetTypeInfo(descendant).Type;
usedType = usedType as INamedTypeSymbol;
if (usedType != null && usedType.IsDefinedInSource())
{
var def = GetValueOrCreate(usedType, classes);
if (def != definition && !definition.Interfaces.Contains(def) && !definition.BaseClasses.Contains(def))
{
dependencies.Add(def);
}
}
}
}
definition.Dependencies.AddRange(dependencies);
progress?.Report(new TreeBuilderProgress {
totalClasses = types.Count(), doneClasses = i + 1
});
}
return(classes.Values.ToList());
}
void Init()
{
TestId = test.Id.ToString();
TestSourceCodeDocumentId = test.FullyQualifiedName;
if (!string.IsNullOrEmpty(test.CodeFilePath))
{
sourceCodeLocation = new SourceCodeLocation(test.CodeFilePath, test.LineNumber, 0);
}
else
{
TypeSystemService.GetCompilationAsync(Project).ContinueWith((t) => {
var dotIndex = test.FullyQualifiedName.LastIndexOf(".", StringComparison.Ordinal);
var className = test.FullyQualifiedName.Remove(dotIndex);
var methodName = test.FullyQualifiedName.Substring(dotIndex + 1);
var bracketIndex = methodName.IndexOf('(');
if (bracketIndex != -1)
{
methodName = methodName.Remove(bracketIndex).Trim();
}
var compilation = t.Result;
if (compilation == null)
{
return;
}
var cls = compilation.GetTypeByMetadataName(className);
if (cls == null)
{
return;
}
IMethodSymbol method = null;
while ((method = cls.GetMembers(methodName).OfType <IMethodSymbol> ().FirstOrDefault()) == null)
{
cls = cls.BaseType;
if (cls == null)
{
return;
}
}
if (method == null)
{
return;
}
var source = method.Locations.FirstOrDefault(l => l.IsInSource);
if (source == null)
{
return;
}
var line = source.GetLineSpan();
sourceCodeLocation = new SourceCodeLocation(source.SourceTree.FilePath, line.StartLinePosition.Line, line.StartLinePosition.Character);
}).Ignore();
}
int index = test.FullyQualifiedName.LastIndexOf('.');
if (index > 0)
{
FixtureTypeName = test.FullyQualifiedName.Substring(0, index);
index = FixtureTypeName.LastIndexOf('.');
if (index > 0)
{
FixtureTypeNamespace = FixtureTypeName.Substring(0, index);
FixtureTypeName = FixtureTypeName.Substring(index + 1);
}
else
{
FixtureTypeNamespace = string.Empty;
}
}
else
{
FixtureTypeNamespace = string.Empty;
FixtureTypeName = string.Empty;
}
name = test.DisplayName;
var obsoletePrefix = string.IsNullOrEmpty(FixtureTypeNamespace) ? FixtureTypeName : FixtureTypeNamespace + "." + FixtureTypeName;
if (test.DisplayName.StartsWith(obsoletePrefix, StringComparison.Ordinal) && test.DisplayName [obsoletePrefix.Length] == '.')
{
name = test.DisplayName.Substring(obsoletePrefix.Length + 1);
}
}