protected ResolveResult Resolve(string code)
{
CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")));
TextLocation[] dollars = FindDollarSigns(code).ToArray();
Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node");
SetUp();
CSharpParsedFile parsedFile = new CSharpParsedFile("test.cs", resolver.CurrentUsingScope);
TypeSystemConvertVisitor convertVisitor = new TypeSystemConvertVisitor(parsedFile, resolver.CurrentUsingScope, null);
cu.AcceptVisitor(convertVisitor, null);
project.UpdateProjectContent(null, convertVisitor.ParsedFile);
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);
var navigator = new NodeListResolveVisitorNavigator(new[] { fnv.ResultNode });
ResolveResult rr;
using (var context = this.context.Synchronize()) {
ResolveVisitor rv = new ResolveVisitor(new CSharpResolver(context), convertVisitor.ParsedFile, navigator);
rv.Scan(cu);
rr = rv.GetResolveResult(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);
}
/// <summary>
/// Resolves the specified node.
/// </summary>
public ResolveResult Resolve(AstNode node, CancellationToken cancellationToken = default(CancellationToken))
{
if (node == null || node.IsNull)
{
return(ErrorResolveResult.UnknownError);
}
InitResolver(node);
lock (resolveVisitor) {
ResolveResult rr = resolveVisitor.GetResolveResult(node);
Debug.Assert(rr != null);
return(rr);
}
}
/// <summary>
/// Resolves the specified node.
/// </summary>
public ResolveResult Resolve(AstNode node, CancellationToken cancellationToken = default(CancellationToken))
{
if (node == null || node.IsNull || IsUnresolvableNode(node))
{
return(ErrorResolveResult.UnknownError);
}
InitResolver();
resolveVisitor.cancellationToken = cancellationToken;
try {
ResolveResult rr = resolveVisitor.GetResolveResult(node);
Debug.Assert(rr != null);
return(rr);
} finally {
resolveVisitor.cancellationToken = CancellationToken.None;
}
}
/// <summary>
/// Resolves the specified node.
/// </summary>
public ResolveResult Resolve(AstNode node, CancellationToken cancellationToken = default(CancellationToken))
{
if (node == null || node.IsNull || IsUnresolvableNode(node))
{
return(ErrorResolveResult.UnknownError);
}
lock (resolveVisitor) {
InitResolver();
resolveVisitor.cancellationToken = cancellationToken;
try {
ResolveResult rr = resolveVisitor.GetResolveResult(node);
if (rr == null)
{
Debug.Fail(node.GetType() + " resolved to null.", node.StartLocation + ":'" + node.GetText() + "'");
}
return(rr);
} finally {
resolveVisitor.cancellationToken = CancellationToken.None;
}
}
}
public static ResolveResult Resolve(ITypeResolveContext context, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location,
CancellationToken cancellationToken = default(CancellationToken))
{
AstNode node = cu.GetNodeAt(location);
if (node == null)
{
return(null);
}
AstNode resolvableNode;
if (node is AstType)
{
resolvableNode = node;
if (resolvableNode.Parent is ComposedType)
{
while (resolvableNode.Parent is ComposedType)
{
resolvableNode = resolvableNode.Parent;
}
//node is preffered over the resolvable node. Which shouldn't be done in the case of nullables, arrays etc.
node = resolvableNode;
}
}
else if (node is Identifier)
{
resolvableNode = node.Parent;
}
else if (node.NodeType == NodeType.Token)
{
if (node.Parent is ConstructorInitializer)
{
resolvableNode = node.Parent;
}
else
{
return(null);
}
}
else
{
// don't resolve arbitrary nodes - we don't want to show tooltips for everything
return(null);
}
InvocationExpression parentInvocation = null;
if ((resolvableNode is IdentifierExpression || resolvableNode is MemberReferenceExpression || resolvableNode is PointerReferenceExpression))
{
// we also need to resolve the invocation
parentInvocation = resolvableNode.Parent as InvocationExpression;
}
IResolveVisitorNavigator navigator;
if (parentInvocation != null)
{
navigator = new NodeListResolveVisitorNavigator(new[] { resolvableNode, parentInvocation });
}
else
{
navigator = new NodeListResolveVisitorNavigator(new[] { resolvableNode });
}
using (var ctx = context.Synchronize()) {
CSharpResolver resolver = new CSharpResolver(ctx, cancellationToken);
ResolveVisitor v = new ResolveVisitor(resolver, parsedFile, navigator);
v.Scan(cu);
// Prefer the RR from the token itself, if it was assigned a ResolveResult
// (this can happen with the identifiers in various nodes such as catch clauses or foreach statements)
ResolveResult rr = v.GetResolveResult(node) ?? v.GetResolveResult(resolvableNode);
if (rr is MethodGroupResolveResult && parentInvocation != null)
{
return(v.GetResolveResult(parentInvocation));
}
else
{
return(rr);
}
}
}
