/// <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 Task<CSharpAstResolver> 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 resolverAnnotation = document.Annotation<ResolverAnnotation> ();
if (resolverAnnotation != null) {
if (resolverAnnotation.ParsedFile == parsedFile)
return resolverAnnotation.Task;
document.RemoveAnnotations<ResolverAnnotation> ();
}
var resolveTask = Task.Factory.StartNew (delegate {
var result = new CSharpAstResolver (document.Compilation, unit, parsedFile);
result.ApplyNavigator (new ConstantModeResolveVisitorNavigator (ResolveVisitorNavigationMode.Resolve, null));
return result;
});
document.AddAnnotation (new ResolverAnnotation {
Task = resolveTask,
ParsedFile = parsedFile
});
return resolveTask;
}
public override IEntity ResolveCref(string cref)
{
if (cref.Length > 2 && cref[1] == ':') {
// resolve ID string
return base.ResolveCref(cref);
}
var documentationReference = new CSharpParser().ParseDocumentationReference(cref);
var csharpContext = context as CSharpTypeResolveContext;
CSharpResolver resolver;
if (csharpContext != null) {
resolver = new CSharpResolver(csharpContext);
} else {
resolver = new CSharpResolver(context.Compilation);
}
var astResolver = new CSharpAstResolver(resolver, documentationReference);
var rr = astResolver.Resolve(documentationReference);
MemberResolveResult mrr = rr as MemberResolveResult;
if (mrr != null)
return mrr.Member;
TypeResolveResult trr = rr as TypeResolveResult;
if (trr != null)
return trr.Type.GetDefinition();
return null;
}
public RenameResponse Rename(RenameRequest req)
{
var project = _solution.ProjectContainingFile(req.FileName);
var syntaxTree = project.CreateParser().Parse(req.Buffer, req.FileName);
var sourceNode = syntaxTree.GetNodeAt(req.Line, req.Column);
if(sourceNode == null)
return new RenameResponse();
var originalName = sourceNode.GetText();
IEnumerable<AstNode> nodes = _findUsagesHandler.FindUsageNodes(req).ToArray();
var response = new RenameResponse();
var modfiedFiles = new List<ModifiedFileResponse>();
response.Changes = modfiedFiles;
foreach (IGrouping<string, AstNode> groupedNodes in nodes.GroupBy(n => n.GetRegion().FileName.FixPath()))
{
string fileName = groupedNodes.Key;
OmniSharpRefactoringContext context;
if (groupedNodes.Key != req.FileName)
{
var file = _solution.GetFile(fileName);
var bufferParser = new BufferParser(_solution);
var content = bufferParser.ParsedContent(file.Document.Text, file.FileName);
var resolver = new CSharpAstResolver(content.Compilation, content.SyntaxTree, content.UnresolvedFile);
context = new OmniSharpRefactoringContext(file.Document, resolver);
}
else
{
context = OmniSharpRefactoringContext.GetContext(_bufferParser, req);
}
string modifiedBuffer = null;
foreach (var node in groupedNodes.Where(n => n.GetText() == originalName))
{
using (var script = new OmniSharpScript(context))
{
script.Rename(node, req.RenameTo);
modifiedBuffer = script.CurrentDocument.Text;
}
}
if (modifiedBuffer != null)
{
var modifiedFile = new ModifiedFileResponse
{
FileName
= fileName,
Buffer = modifiedBuffer
};
modfiedFiles.Add(modifiedFile);
response.Changes = modfiedFiles;
_bufferParser.ParsedContent(modifiedBuffer, fileName);
_solution.GetFile(fileName).Update(modifiedBuffer);
}
}
return response;
}
public SemanticErrorsResponse FindSemanticErrors(Request request)
{
var clientFilename = request.FileName.ApplyPathReplacementsForClient();
var project = _solution.ProjectContainingFile(request.FileName);
project.UpdateFile(request.FileName, request.Buffer);
var solutionSnapshot = new DefaultSolutionSnapshot(_solution.Projects.Select(i => i.ProjectContent));
SyntaxTree syntaxTree;
if(project.CompilerSettings!=null){
syntaxTree = new CSharpParser(project.CompilerSettings).Parse(request.Buffer, request.FileName);
}else{
syntaxTree = new CSharpParser().Parse(request.Buffer, request.FileName);
}
var resolver = new CSharpAstResolver(solutionSnapshot.GetCompilation(project.ProjectContent), syntaxTree);
var navigator = new SemanticErrorsNavigator();
resolver.ApplyNavigator(navigator);
var errors = navigator.GetErrors()
.Where(e => ShouldIncludeIssue(e.Message))
.Select(i => new Error
{
FileName = clientFilename,
Message = i.Message,
Line = i.StartLocation.Line,
Column = i.EndLocation.Column,
EndLine = i.EndLocation.Line,
EndColumn = i.EndLocation.Column
});
return new SemanticErrorsResponse
{
Errors = errors,
};
}
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);
OmniSharpRefactoringContext refactoringContext;
if(request is CodeActionRequest)
{
var car = request as CodeActionRequest;
if(car.SelectionStartColumn.HasValue)
{
var startLocation
= new TextLocation(car.SelectionStartLine.Value, car.SelectionStartColumn.Value);
var endLocation
= new TextLocation(car.SelectionEndLine.Value, car.SelectionEndColumn.Value);
refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location, startLocation, endLocation);
}
else
{
refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location);
}
}
else
{
refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location);
}
refactoringContext.Services.AddService (typeof(NamingConventionService), new DefaultNameService ());
return refactoringContext;
}
public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node,
CancellationToken cancellationToken = default(CancellationToken))
{
node = syntaxTree.GetNodeAt(location);
if (node == null || node is ArrayInitializerExpression)
return null;
if (node.Parent is UsingAliasDeclaration && node.Role == UsingAliasDeclaration.AliasRole) {
var r = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
return r.Resolve(((UsingAliasDeclaration)node.Parent).Import, cancellationToken);
}
if (CSharpAstResolver.IsUnresolvableNode(node)) {
if (node is Identifier) {
node = node.Parent;
} else if (node.NodeType == NodeType.Token) {
if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer) {
// There's no other place where one could hover to see the indexer's tooltip,
// so we need to resolve it when hovering over the '[' or ']'.
// For constructor initializer, the same applies to the 'base'/'this' token.
node = node.Parent;
} else {
return null;
}
} else {
// don't resolve arbitrary nodes - we don't want to show tooltips for everything
return null;
}
} else {
// It's a resolvable node.
// However, we usually don't want to show the tooltip everywhere
// For example, hovering with the mouse over an empty line between two methods causes
// node==TypeDeclaration, but we don't want to show any tooltip.
if (!node.GetChildByRole(Roles.Identifier).IsNull) {
// We'll suppress the tooltip for resolvable nodes if there is an identifier that
// could be hovered over instead:
return null;
}
}
if (node == null)
return null;
if (node.Parent is ObjectCreateExpression && node.Role == Roles.Type) {
node = node.Parent;
}
InvocationExpression parentInvocation = null;
if ((node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression) && node.Role != Roles.Argument) {
// we also need to resolve the invocation
parentInvocation = node.Parent as InvocationExpression;
}
// TODO: I think we should provide an overload so that an existing CSharpAstResolver can be reused
CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
ResolveResult rr = resolver.Resolve(node, cancellationToken);
if (rr is MethodGroupResolveResult && parentInvocation != null)
return resolver.Resolve(parentInvocation);
else
return rr;
}
public static void RunTest(CSharpFile file)
{
CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile);
var navigator = new ValidatingResolveAllNavigator(file.FileName);
resolver.ApplyNavigator(navigator, CancellationToken.None);
navigator.Validate(resolver, file.SyntaxTree);
}
public static void RunTest(CSharpFile file)
{
CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile);
var navigator = new ValidatingResolveAllNavigator(file.FileName);
resolver.ApplyNavigator(navigator, CancellationToken.None);
navigator.Validate(file.CompilationUnit);
}
static IEnumerable<IType> GetAllValidTypesFromInvocation(CSharpAstResolver resolver, InvocationExpression invoke, AstNode parameter)
{
int index = GetArgumentIndex(invoke.Arguments, parameter);
if (index < 0)
yield break;
var targetResult = resolver.Resolve(invoke.Target) as MethodGroupResolveResult;
if (targetResult != null) {
foreach (var method in targetResult.Methods) {
if (index < method.Parameters.Count) {
if (method.Parameters [index].IsParams) {
var arrayType = method.Parameters [index].Type as ArrayType;
if (arrayType != null)
yield return arrayType.ElementType;
}
yield return method.Parameters [index].Type;
}
}
foreach (var extMethods in targetResult.GetExtensionMethods ()) {
foreach (var extMethod in extMethods) {
if (index + 1 < extMethod.Parameters.Count) {
if (extMethod.Parameters [index + 1].IsParams) {
var arrayType = extMethod.Parameters [index + 1].Type as ArrayType;
if (arrayType != null)
yield return arrayType.ElementType;
}
yield return extMethod.Parameters [index + 1].Type;
}
}
}
}
}
public ToolTipData (ICSharpCode.NRefactory.CSharp.SyntaxTree unit, ICSharpCode.NRefactory.Semantics.ResolveResult result, ICSharpCode.NRefactory.CSharp.AstNode node, CSharpAstResolver file)
{
this.Unit = unit;
this.Result = result;
this.Node = node;
this.Resolver = file;
}
/// <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 Task<CSharpAstResolver> GetSharedResolver (this Document document)
{
var parsedDocument = document.ParsedDocument;
if (parsedDocument == null || document.IsProjectContextInUpdate || document.Project != null && !(document.Project is DotNetProject))
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;
if (resolverAnnotation.SharedTokenSource != null)
resolverAnnotation.SharedTokenSource.Cancel ();
document.RemoveAnnotations<ResolverAnnotation> ();
}
var tokenSource = new CancellationTokenSource ();
var token = tokenSource.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 = resolveTask.ContinueWith (t => {
if (t.IsCanceled)
return null;
if (t.IsFaulted) {
var ex = t.Exception.Flatten ().InnerException;
if (!(ex is TaskCanceledException))
LoggingService.LogWarning ("Exception while getting shared AST resolver.", ex);
return null;
}
return t.Result;
}, TaskContinuationOptions.ExecuteSynchronously);
document.AddAnnotation (new ResolverAnnotation {
Task = wrapper,
ParsedFile = parsedFile,
SharedTokenSource = tokenSource
});
return wrapper;
}
public TestRefactoringContext (IDocument document, TextLocation location, CSharpAstResolver resolver) : base(resolver, CancellationToken.None)
{
this.doc = document;
this.location = location;
this.UseExplicitTypes = UseExplict;
UseExplict = false;
Services.AddService (typeof(NamingConventionService), new TestNameService ());
}
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);
}
}
private OmniSharpRefactoringContext(IDocument document, CSharpAstResolver resolver, TextLocation location, TextLocation selectionStart, TextLocation selectionEnd)
: base(resolver, CancellationToken.None)
{
_document = document;
_location = location;
_selectionStart = selectionStart;
_selectionEnd = selectionEnd;
}
public JavaMethodVisitor(CSharpAstResolver resolver, StreamWriter writer)
{
this.m_Resolver = resolver;
this.m_Writer = writer;
this.m_BytecodeWriter = new JavaBytecodeWriter(writer);
this.m_Locals.Add("~dummy0", 0);
this.m_Locals.Add("~dummy1", 1);
}
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;
}
private OmniSharpRefactoringContext GetRefactoringContext(Request req)
{
var q = _bufferParser.ParsedContent(req.Buffer, req.FileName);
var resolver = new CSharpAstResolver(q.Compilation, q.SyntaxTree, q.UnresolvedFile);
var doc = new StringBuilderDocument(req.Buffer);
var location = new TextLocation(req.Line, req.Column);
var refactoringContext = new OmniSharpRefactoringContext(doc, location, resolver);
return refactoringContext;
}
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 ());
Services.AddService (typeof(CodeGenerationService), new DefaultCodeGenerationService ());
}
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();
}
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 ICodeContext ResolveContext(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken)
{
var decompiledParseInfo = parseInfo as ILSpyFullParseInformation;
if (decompiledParseInfo == null)
throw new ArgumentException("ParseInfo does not have SyntaxTree");
var syntaxTree = decompiledParseInfo.SyntaxTree;
var node = syntaxTree.GetNodeAt(location);
if (node == null)
return null; // null result is allowed; the parser service will substitute a dummy context
var resolver = new CSharpAstResolver(compilation, syntaxTree, null);
return resolver.GetResolverStateBefore(node);
}
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();
}
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);
}
/// <summary>
/// Finds all references in the given file.
/// </summary>
/// <param name="searchScopes">The search scopes for which to look.</param>
/// <param name="parsedFile">The type system representation of the file being searched.</param>
/// <param name="compilationUnit">The compilation unit of the file being searched.</param>
/// <param name="callback">Callback used to report the references that were found.</param>
/// <param name="cancellationToken">Cancellation token.</param>
public void FindReferencesInFile(IList <IFindReferenceSearchScope> searchScopes, CSharpParsedFile parsedFile, CompilationUnit compilationUnit,
ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
{
if (searchScopes == null)
{
throw new ArgumentNullException("searchScopes");
}
if (parsedFile == null)
{
throw new ArgumentNullException("parsedFile");
}
if (compilationUnit == null)
{
throw new ArgumentNullException("compilationUnit");
}
if (compilation == null)
{
throw new ArgumentNullException("compilation");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
if (searchScopes.Count == 0)
{
return;
}
IResolveVisitorNavigator navigator;
if (searchScopes.Count == 1)
{
navigator = searchScopes[0].GetNavigator(compilation, callback);
}
else
{
IResolveVisitorNavigator[] navigators = new IResolveVisitorNavigator[searchScopes.Count];
for (int i = 0; i < navigators.Length; i++)
{
navigators[i] = searchScopes[i].GetNavigator(compilation, callback);
}
navigator = new CompositeResolveVisitorNavigator(navigators);
}
cancellationToken.ThrowIfCancellationRequested();
navigator = new DetectSkippableNodesNavigator(navigator, compilationUnit);
cancellationToken.ThrowIfCancellationRequested();
CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
resolver.ApplyNavigator(navigator, cancellationToken);
}
public static SDRefactoringContext Create(ITextEditor editor, CancellationToken cancellationToken)
{
var parseInfo = SD.ParserService.Parse(editor.FileName, editor.Document, cancellationToken: cancellationToken) as CSharpFullParseInformation;
var compilation = SD.ParserService.GetCompilationForFile(editor.FileName);
CSharpAstResolver resolver;
if (parseInfo != null) {
resolver = parseInfo.GetResolver(compilation);
} else {
// create dummy refactoring context
resolver = new CSharpAstResolver(compilation, new SyntaxTree());
}
var context = new SDRefactoringContext(editor, resolver, editor.Caret.Location, cancellationToken);
return context;
}
internal override void NavigatorDone(CSharpAstResolver resolver, CancellationToken cancellationToken)
{
foreach (var expr in potentialMethodGroupConversions)
{
var conversion = resolver.GetConversion(expr, cancellationToken);
if (conversion.IsMethodGroupConversion && conversion.Method.MemberDefinition == method)
{
IType targetType = resolver.GetExpectedType(expr, cancellationToken);
ResolveResult result = resolver.Resolve(expr, cancellationToken);
ReportMatch(expr, new ConversionResolveResult(targetType, result, conversion));
}
}
base.NavigatorDone(resolver, cancellationToken);
}
public static SDRefactoringContext Create(FileName fileName, ITextSource textSource, TextLocation location = default(TextLocation), CancellationToken cancellationToken = default(CancellationToken))
{
var parseInfo = SD.ParserService.Parse(fileName, textSource, cancellationToken: cancellationToken) as CSharpFullParseInformation;
var compilation = SD.ParserService.GetCompilationForFile(fileName);
CSharpAstResolver resolver;
if (parseInfo != null) {
resolver = parseInfo.GetResolver(compilation);
} else {
// create dummy refactoring context
resolver = new CSharpAstResolver(compilation, new SyntaxTree());
}
var context = new SDRefactoringContext(textSource, resolver, location, 0, 0, cancellationToken);
return context;
}
public CSharpAstResolver GetResolver(ICompilation compilation)
{
// Cache the resolver within the compilation.
// (caching in the parse information could prevent the compilation from being garbage-collected)
// Also, don't cache CSharpAstResolvers for every file - doing so would require too much memory,
// and we usually only need to access the same file several times.
// So we use a static key to get the resolver, and verify that it belongs to this parse information.
var resolver = compilation.CacheManager.GetShared(ResolverCacheKey) as CSharpAstResolver;
if (resolver == null || resolver.RootNode != syntaxTree || resolver.UnresolvedFile != UnresolvedFile) {
resolver = new CSharpAstResolver(compilation, syntaxTree, UnresolvedFile);
compilation.CacheManager.SetShared(ResolverCacheKey, resolver);
}
return resolver;
}
public static void RunTestWithoutUnresolvedFile(CSharpFile file)
{
CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree);
var navigator = new ValidatingResolveAllNavigator(file.FileName);
resolver.ApplyNavigator(navigator, CancellationToken.None);
navigator.Validate(resolver, file.SyntaxTree);
CSharpAstResolver originalResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile);
foreach (var node in file.SyntaxTree.DescendantsAndSelf) {
var originalResult = originalResolver.Resolve(node);
var result = resolver.Resolve(node);
if (!RandomizedOrderResolverTest.IsEqualResolveResult(result, originalResult)) {
Console.WriteLine("Got different without IUnresolvedFile at " + file.FileName + ":" + node.StartLocation);
}
}
}
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 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])));
}
static IEnumerable<IType> GetAllValidTypesFromObjectCreation(CSharpAstResolver resolver, ObjectCreateExpression invoke, AstNode parameter)
{
int index = GetArgumentIndex(invoke.Arguments, parameter);
if (index < 0)
yield break;
var targetResult = resolver.Resolve(invoke.Type);
if (targetResult is TypeResolveResult) {
var type = ((TypeResolveResult)targetResult).Type;
if (type.Kind == TypeKind.Delegate && index == 0) {
yield return type;
yield break;
}
foreach (var constructor in type.GetConstructors ()) {
if (index < constructor.Parameters.Count)
yield return constructor.Parameters [index].Type;
}
}
}
static IEnumerable<IType> GetAllValidTypesFromInvocation(CSharpAstResolver resolver, InvocationExpression invoke, AstNode parameter)
{
int index = GetArgumentIndex(invoke.Arguments, parameter);
if (index < 0)
yield break;
var targetResult = resolver.Resolve(invoke.Target) as MethodGroupResolveResult;
if (targetResult != null) {
foreach (var method in targetResult.Methods) {
if (index < method.Parameters.Count) {
if (method.Parameters [index].IsParams) {
var arrayType = method.Parameters [index].Type as ArrayType;
if (arrayType != null)
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) {
var arrayType = m.Parameters [correctedIndex].Type as ArrayType;
if (arrayType != null)
yield return arrayType.ElementType;
}
yield return m.Parameters [correctedIndex].Type;
}
}
}
}
}
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();
}
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));
}
internal virtual void NavigatorDone(CSharpAstResolver resolver, CancellationToken cancellationToken)
{
}
public QuickTaskVisitor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver resolver, CancellationToken cancellationToken)
{
this.resolver = resolver;
}
public BaseRefactoringContext(ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver resolver, System.Threading.CancellationToken cancellationToken)
{
this.resolver = resolver;
this.cancellationToken = cancellationToken;
this.referenceFinder = new LocalReferenceFinder(resolver);
}
public static ResolveResult Resolve(Lazy <ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node,
CancellationToken cancellationToken = default(CancellationToken))
{
node = syntaxTree.GetNodeAt(location);
if (node == null || node is ArrayInitializerExpression)
{
return(null);
}
if (node.Parent is UsingAliasDeclaration && node.Role == UsingAliasDeclaration.AliasRole)
{
var r = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
return(r.Resolve(((UsingAliasDeclaration)node.Parent).Import, cancellationToken));
}
if (CSharpAstResolver.IsUnresolvableNode(node))
{
if (node is Identifier)
{
node = node.Parent;
}
else if (node.NodeType == NodeType.Token)
{
if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer || node.Role == IndexerDeclaration.ThisKeywordRole)
{
// There's no other place where one could hover to see the indexer's tooltip,
// so we need to resolve it when hovering over the '[' or ']'.
// For constructor initializer, the same applies to the 'base'/'this' token.
node = node.Parent;
}
else if (node.Parent is BinaryOperatorExpression || node.Parent is UnaryOperatorExpression)
{
// Resolve user-defined operator
node = node.Parent;
}
else
{
return(null);
}
}
else
{
// don't resolve arbitrary nodes - we don't want to show tooltips for everything
return(null);
}
}
else
{
// It's a resolvable node.
// However, we usually don't want to show the tooltip everywhere
// For example, hovering with the mouse over an empty line between two methods causes
// node==TypeDeclaration, but we don't want to show any tooltip.
if (!node.GetChildByRole(Roles.Identifier).IsNull)
{
// We'll suppress the tooltip for resolvable nodes if there is an identifier that
// could be hovered over instead:
return(null);
}
}
if (node == null)
{
return(null);
}
if (node.Parent is ObjectCreateExpression && node.Role == Roles.Type)
{
node = node.Parent;
}
InvocationExpression parentInvocation = null;
if ((node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression) && node.Role != Roles.Argument)
{
// we also need to resolve the invocation
parentInvocation = node.Parent as InvocationExpression;
}
// TODO: I think we should provide an overload so that an existing CSharpAstResolver can be reused
CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
ResolveResult rr = resolver.Resolve(node, cancellationToken);
MethodGroupResolveResult mgrr = rr as MethodGroupResolveResult;
if (mgrr != null)
{
// For method groups, resolve the parent invocation instead.
if (parentInvocation != null)
{
return(resolver.Resolve(parentInvocation));
}
if (node is Expression)
{
// If it's not an invocation, try if it's a conversion to a delegate type:
Conversion c = resolver.GetConversion((Expression)node, cancellationToken);
if (c.IsMethodGroupConversion)
{
return(new MemberResolveResult(mgrr.TargetResult, c.Method));
}
}
}
return(rr);
}
public static ResolveResult Resolve(ICompilation compilation, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location, out AstNode node,
CancellationToken cancellationToken = default(CancellationToken))
{
node = cu.GetNodeAt(location);
if (node == null)
{
return(null);
}
if (CSharpAstResolver.IsUnresolvableNode(node))
{
if (node is Identifier)
{
node = node.Parent;
}
else if (node.NodeType == NodeType.Token)
{
if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer)
{
// There's no other place where one could hover to see the indexer's tooltip,
// so we need to resolve it when hovering over the '[' or ']'.
// For constructor initializer, the same applies to the 'base'/'this' token.
node = node.Parent;
}
else
{
return(null);
}
}
else
{
// don't resolve arbitrary nodes - we don't want to show tooltips for everything
return(null);
}
}
else
{
// It's a resolvable node.
// However, we usually don't want to show the tooltip everywhere
// For example, hovering with the mouse over an empty line between two methods causes
// node==TypeDeclaration, but we don't want to show any tooltip.
if (!node.GetChildByRole(AstNode.Roles.Identifier).IsNull)
{
// We'll suppress the tooltip for resolvable nodes if there is an identifier that
// could be hovered over instead:
return(null);
}
}
if (node == null)
{
return(null);
}
if (node.Parent is ObjectCreateExpression && node.Role == ObjectCreateExpression.Roles.Type)
{
node = node.Parent;
}
InvocationExpression parentInvocation = null;
if (node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression)
{
// we also need to resolve the invocation
parentInvocation = node.Parent as InvocationExpression;
}
CSharpAstResolver resolver = new CSharpAstResolver(compilation, cu, parsedFile);
ResolveResult rr = resolver.Resolve(node, cancellationToken);
if (rr is MethodGroupResolveResult && parentInvocation != null)
{
return(resolver.Resolve(parentInvocation));
}
else
{
return(rr);
}
}
