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));
}
