public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
var result = resolver.Resolve(methodDeclaration) as MemberResolveResult;
if (result == null)
{
return;
}
var method = result.Member as IMethod;
UnitTest test = null;
foreach (var attr in method.Attributes)
{
if (attr.AttributeType.ReflectionName == "NUnit.Framework.TestAttribute")
{
if (test == null)
{
test = new UnitTest(methodDeclaration.NameToken.StartLocation.Line);
test.UnitTestIdentifier = GetFullName((TypeDeclaration)methodDeclaration.Parent) + "." + methodDeclaration.Name;
foundTests.Add(test);
}
}
}
if (test != null)
{
foreach (var attr in method.Attributes)
{
if (attr.AttributeType.ReflectionName == "NUnit.Framework.TestCaseAttribute")
{
test.TestCases.Add("(" + BuildArguments(attr) + ")");
}
else if (attr.AttributeType.ReflectionName == "NUnit.Framework.IgnoreAttribute")
{
test.IsIgnored = true;
}
}
}
}
void ResolveButtonClick(object sender, EventArgs e)
{
IProjectContent project = new CSharpProjectContent();
var unresolvedFile = syntaxTree.ToTypeSystem();
project = project.AddOrUpdateFiles(unresolvedFile);
project = project.AddAssemblyReferences(builtInLibs.Value);
ICompilation compilation = project.CreateCompilation();
ResolveResult result;
IType expectedType = null;
Conversion conversion = null;
if (csharpTreeView.SelectedNode != null)
{
var selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag;
CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
result = resolver.Resolve(selectedNode);
// CSharpAstResolver.Resolve() never returns null
Expression expr = selectedNode as Expression;
if (expr != null)
{
expectedType = resolver.GetExpectedType(expr);
conversion = resolver.GetConversion(expr);
}
}
else
{
TextLocation location = GetTextLocation(csharpCodeTextBox, csharpCodeTextBox.SelectionStart);
result = ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location);
if (result == null)
{
MessageBox.Show("Could not find a resolvable node at the caret location.");
return;
}
}
using (var dlg = new SemanticTreeDialog()) {
dlg.AddRoot("Resolve() = ", result);
if (expectedType != null)
{
dlg.AddRoot("GetExpectedType() = ", expectedType);
}
if (conversion != null)
{
dlg.AddRoot("GetConversion() = ", conversion);
}
dlg.ShowDialog();
}
}
void VisitVisibleNodes(AstNode node, IResolveVisitorNavigator currentNavigator, CSharpAstResolver resolver, int start, int end)
{
if (!CSharpAstResolver.IsUnresolvableNode(node))
{
currentNavigator.Resolved(node, resolver.Resolve(node, caretMovementTokenSource.Token));
}
for (var child = node.FirstChild; child != null; child = child.NextSibling)
{
if (child.StartLocation.Line <= end && child.EndLocation.Line >= start)
{
VisitVisibleNodes(child, currentNavigator, resolver, start, end);
}
}
}
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);
}
}
}
}
}
protected override void VisitChildren(AstNode node)
{
if (referenceFinder.visitedRoots.Contains(node))
{
return;
}
if (resolver.Resolve(node) is LocalResolveResult localResolveResult && !processedVariables.Contains(localResolveResult.Variable))
{
referenceFinder.references.Add(localResolveResult.Variable, new ReferenceResult(node, localResolveResult));
processedVariables.Add(localResolveResult.Variable);
base.VisitChildren(node);
Debug.Assert(processedVariables.Contains(localResolveResult.Variable), "Variable should still be in the list of processed variables.");
processedVariables.Remove(localResolveResult.Variable);
}
public virtual void Validate(CSharpAstResolver resolver, SyntaxTree syntaxTree)
{
foreach (AstNode node in syntaxTree.DescendantsAndSelf.Except(resolvedNodes.Keys))
{
if (!CSharpAstResolver.IsUnresolvableNode(node))
{
Console.WriteLine("Forgot to resolve " + node);
}
}
foreach (var pair in resolvedNodes)
{
if (resolver.Resolve(pair.Key) != pair.Value)
{
throw new InvalidOperationException("Inconsistent result");
}
}
}
static IEnumerable <IType> GuessFromConstructorInitializer(CSharpAstResolver resolver, AstNode expr)
{
var init = expr.Parent as ConstructorInitializer;
var rr = resolver.Resolve(expr.Parent);
int index = GetArgumentIndex(init.Arguments, expr);
if (index >= 0)
{
foreach (var constructor in rr.Type.GetConstructors())
{
if (index < constructor.Parameters.Count)
{
yield return(constructor.Parameters[index].Type);
}
}
}
}
protected override void VisitChildren(AstNode node)
{
if (ErrorResolveResult != null || cancellationToken.IsCancellationRequested)
{
return;
}
if (node is Expression)
{
var rr = resolver.Resolve(node, cancellationToken);
if (rr.IsError)
{
errorResolveResult = rr;
errorNode = node;
}
}
base.VisitChildren(node);
}
private List <AstNode> GetResolvedNodes(ResolveResultType type, AstNode node)
{
var resolvedNodes = new List <AstNode>();
ResolveResult resolveResult = _resolver.Resolve(node);
if (resolveResult != null)
{
var findReferences = new FindReferences();
FoundReferenceCallback callback = delegate(AstNode matchNode, ResolveResult result)
{
resolvedNodes.Add(matchNode);
};
if (type == ResolveResultType.Local)
{
var localResolveResult = resolveResult as LocalResolveResult;
if (localResolveResult != null)
{
findReferences.FindLocalReferences(localResolveResult.Variable, _unresolvedFile, SyntaxTree, _compilation, callback, CancellationToken.None);
}
}
else if (type == ResolveResultType.Member)
{
var memberResolveResult = resolveResult as MemberResolveResult;
if (memberResolveResult != null)
{
var searchScopes = findReferences.GetSearchScopes(memberResolveResult.Member);
findReferences.FindReferencesInFile(searchScopes, _unresolvedFile, SyntaxTree, _compilation, callback, CancellationToken.None);
}
}
else if (type == ResolveResultType.Type)
{
var typeResolveResult = resolveResult as TypeResolveResult;
if (typeResolveResult != null)
{
var searchScopes = findReferences.GetSearchScopes(typeResolveResult.Type.GetDefinition());
findReferences.FindReferencesInFile(searchScopes, _unresolvedFile, SyntaxTree, _compilation, callback, CancellationToken.None);
}
}
}
else
{
}
return(resolvedNodes);
}
public override bool DoMatch(INode other, Match match)
{
if (FixUtil.Instance.NeedFix("ExpressionWithType.DoMatch"))
{
FixUtil.Instance.Fix("ExpressionWithType.DoMatch", this, other, match);
return;
}
Expression expr = other as Expression;
if (expr == null)
{
return(false);
}
ResolveResult result = resolver.Resolve(expr);
return(result.Type.Equals(expectedType));
}
public override bool DoMatch(INode other, Match match)
{
if (FixUtil.Instance.NeedFix("ExpressionWithType.DoMatch"))
{
string strParameter = string.Format("ExpressionWithType,DoMatch,{0},{1},{2}", typeof(object), typeof(INode), typeof(Match));
FixUtil.Instance.Fix(strParameter, this, other, match);
return;
}
Expression expr = other as Expression;
if (expr == null)
{
return(false);
}
ResolveResult result = resolver.Resolve(expr);
return(result.Type.Equals(expectedType));
}
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);
}
}
}
static IEnumerable <IType> GetAllValidTypesFromInvokation(CSharpAstResolver resolver, InvocationExpression invoke, AstNode parameter)
{
int index = GetArgumentIndex(invoke.Arguments, parameter);
if (index < 0)
{
yield break;
}
var targetResult = resolver.Resolve(invoke.Target);
if (targetResult is MethodGroupResolveResult)
{
foreach (var method in ((MethodGroupResolveResult)targetResult).Methods)
{
if (index < method.Parameters.Count)
{
yield return(method.Parameters [index].Type);
}
}
}
}
public void MethodParamsReturnAttributes()
{
const String source = "namespace ns\r\n" +
"{\r\n" +
" [System.AttributeUsage(System.AttributeTargets.Parameter)]\r\n" +
" public class AttrA : System.Attribute\r\n" +
" {\r\n" +
" }\r\n" +
" [System.AttributeUsage(System.AttributeTargets.ReturnValue)]\r\n" +
" public class AttrB : System.Attribute\r\n" +
" {\r\n" +
" }\r\n" +
" public class SomeClass\r\n" +
" {\r\n" +
" [return: AttrB]\r\n" +
" public string SomeMethod(int p1, [AttrA]string p2) { return \"iddqd\"; }\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 == "SomeMethod");
ResolveResult result = resolver.Resolve(method);
MemberResolveResult memberResult = (MemberResolveResult)result;
IMember member = memberResult.Member;
}
public void AddChildren(AstNode node, CSharpAstResolver visitor, TreeIter iter)
{
if (node == null)
{
return;
}
iterDict [node] = iter;
foreach (var child in node.Children)
{
ResolveResult result = null;
try {
if (child is Expression)
{
result = visitor.Resolve(child, CancellationToken.None);
}
} catch (Exception) {
result = null;
}
var childIter = store.AppendValues(iter, GetNodeTitle(child), result != null ? result.ToString() : "", child, GetIcon(child));
AddChildren(child, visitor, childIter);
}
}
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);
}
static ResolveResult ResolveSnippet(string fileName, TextLocation location, string contextCode, string codeSnippet, ICompilation compilation)
{
CSharpParser contextParser = new CSharpParser();
var cu = contextParser.Parse(contextCode, fileName);
CSharpAstResolver contextResolver = new CSharpAstResolver(compilation, cu);
var node = cu.GetNodeAt(location);
CSharpResolver context;
if (node != null)
{
context = contextResolver.GetResolverStateAfter(node, CancellationToken.None);
}
else
{
context = new CSharpResolver(compilation);
}
CSharpParser parser = new CSharpParser();
var expr = parser.ParseExpression(codeSnippet);
Assert.IsFalse(parser.HasErrors);
CSharpAstResolver snippetResolver = new CSharpAstResolver(context, expr);
return(snippetResolver.Resolve(expr, CancellationToken.None));
}
protected Tuple <ResolveResult, CSharpResolver> ResolveExpression(AstNode expr, CompilationUnit unit)
{
if (expr == null)
{
return(null);
}
AstNode resolveNode;
if (expr is Expression || expr is AstType)
{
resolveNode = expr;
}
else if (expr is VariableDeclarationStatement)
{
resolveNode = ((VariableDeclarationStatement)expr).Type;
}
else
{
resolveNode = expr;
}
try {
var ctx = CSharpParsedFile.GetResolver(Compilation, location);
var root = expr.AncestorsAndSelf.FirstOrDefault(n => n is EntityDeclaration || n is CompilationUnit);
if (root == null)
{
return(null);
}
var csResolver = new CSharpAstResolver(ctx, root, CSharpParsedFile);
var result = csResolver.Resolve(resolveNode);
var state = csResolver.GetResolverStateBefore(resolveNode);
return(Tuple.Create(result, state));
} catch (Exception e) {
Console.WriteLine(e);
return(null);
}
}
public ResolveResult Resolve(AstNode node)
{
return(resolver.Resolve(node));
}
public ResolveResult ResolveNode(AstNode node)
{
var syntaxTree = node.GetParent <SyntaxTree>();
InitResolver(syntaxTree);
var result = resolver.Resolve(node);
if (result is MethodGroupResolveResult resolveResult && node.Parent != null)
{
var methodGroupResolveResult = resolveResult;
var parentResolveResult = ResolveNode(node.Parent);
var parentInvocation = parentResolveResult as InvocationResolveResult;
IParameterizedMember method = methodGroupResolveResult.Methods.LastOrDefault();
bool isInvocation = node.Parent is InvocationExpression invocationExp && (invocationExp.Target == node);
if (node is Expression expression)
{
var conversion = Resolver.GetConversion(expression);
if (conversion != null && conversion.IsMethodGroupConversion)
{
return(new MemberResolveResult(new TypeResolveResult(conversion.Method.DeclaringType), conversion.Method));
}
}
if (isInvocation && parentInvocation != null)
{
var or = methodGroupResolveResult.PerformOverloadResolution(compilation, parentInvocation.GetArgumentsForCall().ToArray());
if (or.FoundApplicableCandidate)
{
method = or.BestCandidate;
return(new MemberResolveResult(new TypeResolveResult(method.DeclaringType), method));
}
}
if (parentInvocation != null && method == null)
{
if (methodGroupResolveResult.TargetType is DefaultResolvedTypeDefinition typeDef)
{
var methods = typeDef.Methods.Where(m => m.Name == methodGroupResolveResult.MethodName);
method = methods.FirstOrDefault();
}
}
if (method == null)
{
var extMethods = methodGroupResolveResult.GetEligibleExtensionMethods(false);
if (!extMethods.Any())
{
extMethods = methodGroupResolveResult.GetExtensionMethods();
}
if (!extMethods.Any() || !extMethods.First().Any())
{
throw new EmitterException(node, "Cannot find method defintion");
}
method = extMethods.First().First();
}
if (parentInvocation == null || method.FullName != parentInvocation.Member.FullName)
{
MemberResolveResult memberResolveResult = new MemberResolveResult(new TypeResolveResult(method.DeclaringType), method);
return(memberResolveResult);
}
return(parentResolveResult);
}
if ((result == null || result.IsError))
{
if (result is CSharpInvocationResolveResult invocationResult && invocationResult.OverloadResolutionErrors != OverloadResolutionErrors.None)
{
return(result);
}
if (result.IsError)
{
Logger.ZLogTrace("Node resolving has failed {0}: {1}", node.StartLocation, node.ToString());
}
}
return(result);
}
public NestedFunctionData GatherNestedFunctions(AstNode node)
{
currentFunction = new NestedFunctionData(null)
{
DefinitionNode = node, BodyNode = GetBodyNode(node), ResolveResult = _resolver.Resolve(node) as LambdaResolveResult
};
VisitChildren(node);
return(currentFunction);
}
internal static IEnumerable <IType> GetValidTypes(CSharpAstResolver resolver, AstNode expr)
{
if (expr.Parent is DirectionExpression)
{
var parent = expr.Parent.Parent;
if (parent is InvocationExpression)
{
var invoke = (InvocationExpression)parent;
return(GetAllValidTypesFromInvokation(resolver, invoke, expr.Parent));
}
}
if (expr.Parent is ArrayInitializerExpression)
{
if (expr is NamedExpression)
{
return new [] { resolver.Resolve(((NamedExpression)expr).Expression).Type }
}
;
var aex = expr.Parent as ArrayInitializerExpression;
if (aex.IsSingleElement)
{
aex = aex.Parent as ArrayInitializerExpression;
}
var type = GetElementType(resolver, resolver.Resolve(aex.Parent).Type);
if (type.Kind != TypeKind.Unknown)
{
return new [] { type }
}
;
}
if (expr.Parent is ObjectCreateExpression)
{
var invoke = (ObjectCreateExpression)expr.Parent;
return(GetAllValidTypesFromObjectCreation(resolver, invoke, expr));
}
if (expr.Parent is ArrayCreateExpression)
{
var ace = (ArrayCreateExpression)expr.Parent;
if (!ace.Type.IsNull)
{
return(new [] { resolver.Resolve(ace.Type).Type });
}
}
if (expr.Parent is InvocationExpression)
{
var parent = expr.Parent;
if (parent is InvocationExpression)
{
var invoke = (InvocationExpression)parent;
return(GetAllValidTypesFromInvokation(resolver, invoke, expr));
}
}
if (expr.Parent is VariableInitializer)
{
var initializer = (VariableInitializer)expr.Parent;
var field = initializer.GetParent <FieldDeclaration>();
if (field != null)
{
return new [] { resolver.Resolve(field.ReturnType).Type }
}
;
return(new [] { resolver.Resolve(initializer).Type });
}
if (expr.Parent is CastExpression)
{
var cast = (CastExpression)expr.Parent;
return(new [] { resolver.Resolve(cast.Type).Type });
}
if (expr.Parent is AsExpression)
{
var cast = (AsExpression)expr.Parent;
return(new [] { resolver.Resolve(cast.Type).Type });
}
if (expr.Parent is AssignmentExpression)
{
var assign = (AssignmentExpression)expr.Parent;
var other = assign.Left == expr ? assign.Right : assign.Left;
return(new [] { resolver.Resolve(other).Type });
}
if (expr.Parent is BinaryOperatorExpression)
{
var assign = (BinaryOperatorExpression)expr.Parent;
var other = assign.Left == expr ? assign.Right : assign.Left;
return(new [] { resolver.Resolve(other).Type });
}
if (expr.Parent is ReturnStatement)
{
var state = resolver.GetResolverStateBefore(expr.Parent);
if (state != null && state.CurrentMember != null)
{
return new [] { state.CurrentMember.ReturnType }
}
;
}
if (expr.Parent is YieldReturnStatement)
{
var state = resolver.GetResolverStateBefore(expr);
if (state != null && (state.CurrentMember.ReturnType is ParameterizedType))
{
var pt = (ParameterizedType)state.CurrentMember.ReturnType;
if (pt.FullName == "System.Collections.Generic.IEnumerable")
{
return(new [] { pt.TypeArguments.First() });
}
}
}
if (expr.Parent is UnaryOperatorExpression)
{
var uop = (UnaryOperatorExpression)expr.Parent;
switch (uop.Operator)
{
case UnaryOperatorType.Not:
return(new [] { resolver.Compilation.FindType(KnownTypeCode.Boolean) });
case UnaryOperatorType.Minus:
case UnaryOperatorType.Plus:
case UnaryOperatorType.Increment:
case UnaryOperatorType.Decrement:
case UnaryOperatorType.PostIncrement:
case UnaryOperatorType.PostDecrement:
return(new [] { resolver.Compilation.FindType(KnownTypeCode.Int32) });
}
}
return(Enumerable.Empty <IType>());
}
private void ParseTargetExpression(Expression expression)
{
if (_file != null)
{
var resolver = new CSharpAstResolver(_file.Project.Compilation, _file.SyntaxTree, _file.UnresolvedTypeSystemForFile);
var resolveResult = resolver.Resolve(expression);
if (resolveResult is CSharpInvocationResolveResult)
{
var member = ((CSharpInvocationResolveResult)resolveResult).Member;
var method = member as IMethod;
if (method != null)
{
var callerType = _type;
var callerMethod = _method;
SDType calledType = null;
var sdType = _repository.GetTypeByIdentifier(member.DeclaringType.GetIdentifier());
if (sdType == null)
{
var sdNamespace = _repository.GetNamespaceByIdentifier(member.DeclaringType.Namespace);
sdNamespace = sdNamespace == null ? new SDNamespace(member.DeclaringType.Namespace)
{
IsProjectStranger = true
} : sdNamespace;
calledType = new SDType(member.DeclaringType.GetIdentifier(), member.DeclaringType.Name, sdNamespace)
{
IsProjectStranger = true
};
}
else
{
calledType = sdType;
}
SDMethod calledMethod = null;
if (calledType.IsProjectStranger)
{
calledMethod = new SDMethod(method.GetIdentifier(), method.Name);
}
else
{
SDMethod sdMethod = sdType.Methods.Concat(sdType.Constructors).SingleOrDefault(m => m.Identifier == method.GetIdentifier());
if (sdMethod != null)
{
calledMethod = sdMethod;
}
}
// Only add method, if it is project stranger, public or private (if not only public members option on)
if (calledMethod != null)
{
var token = new SDTargetNode
{
CalledType = calledType,
CallerType = callerType,
CalledMethod = calledMethod,
CallerMethod = callerMethod
};
_tokenList.Add(token);
}
}
}
}
}
public static IEnumerable <IType> GetValidTypes(CSharpAstResolver resolver, AstNode expr)
{
if (expr.Role == Roles.Condition)
{
return(new [] { resolver.Compilation.FindType(KnownTypeCode.Boolean) });
}
var mref = expr as MemberReferenceExpression;
if (mref != null)
{
// case: guess enum when trying to access not existent enum member
var rr = resolver.Resolve(mref.Target);
if (!rr.IsError && rr.Type.Kind == TypeKind.Enum)
{
return new [] { rr.Type }
}
;
}
if (expr.Parent is ParenthesizedExpression || expr.Parent is NamedArgumentExpression)
{
return(GetValidTypes(resolver, expr.Parent));
}
if (expr.Parent is DirectionExpression)
{
var parent = expr.Parent.Parent;
if (parent is InvocationExpression)
{
var invoke = (InvocationExpression)parent;
return(GetAllValidTypesFromInvocation(resolver, invoke, expr.Parent));
}
}
if (expr.Parent is ArrayInitializerExpression)
{
if (expr is NamedExpression)
{
return new [] { resolver.Resolve(((NamedExpression)expr).Expression).Type }
}
;
var aex = expr.Parent as ArrayInitializerExpression;
if (aex.IsSingleElement)
{
aex = aex.Parent as ArrayInitializerExpression;
}
var type = GetElementType(resolver, resolver.Resolve(aex.Parent).Type);
if (type.Kind != TypeKind.Unknown)
{
return new [] { type }
}
;
}
if (expr.Parent is ObjectCreateExpression)
{
var invoke = (ObjectCreateExpression)expr.Parent;
return(GetAllValidTypesFromObjectCreation(resolver, invoke, expr));
}
if (expr.Parent is ArrayCreateExpression)
{
var ace = (ArrayCreateExpression)expr.Parent;
if (!ace.Type.IsNull)
{
return(new [] { resolver.Resolve(ace.Type).Type });
}
}
if (expr.Parent is InvocationExpression)
{
var parent = expr.Parent;
if (parent is InvocationExpression)
{
var invoke = (InvocationExpression)parent;
return(GetAllValidTypesFromInvocation(resolver, invoke, expr));
}
}
if (expr.Parent is VariableInitializer)
{
var initializer = (VariableInitializer)expr.Parent;
var field = initializer.GetParent <FieldDeclaration>();
if (field != null)
{
var rr = resolver.Resolve(field.ReturnType);
if (!rr.IsError)
{
return new [] { rr.Type }
}
;
}
var varStmt = initializer.GetParent <VariableDeclarationStatement>();
if (varStmt != null)
{
var rr = resolver.Resolve(varStmt.Type);
if (!rr.IsError)
{
return new [] { rr.Type }
}
;
}
return(new [] { resolver.Resolve(initializer).Type });
}
if (expr.Parent is CastExpression)
{
var cast = (CastExpression)expr.Parent;
return(new [] { resolver.Resolve(cast.Type).Type });
}
if (expr.Parent is AsExpression)
{
var cast = (AsExpression)expr.Parent;
return(new [] { resolver.Resolve(cast.Type).Type });
}
if (expr.Parent is AssignmentExpression)
{
var assign = (AssignmentExpression)expr.Parent;
var other = assign.Left == expr ? assign.Right : assign.Left;
return(new [] { resolver.Resolve(other).Type });
}
if (expr.Parent is BinaryOperatorExpression)
{
var assign = (BinaryOperatorExpression)expr.Parent;
var other = assign.Left == expr ? assign.Right : assign.Left;
return(new [] { resolver.Resolve(other).Type });
}
if (expr.Parent is ReturnStatement)
{
var parent = expr.Ancestors.FirstOrDefault(n => n is EntityDeclaration || n is AnonymousMethodExpression || n is LambdaExpression);
if (parent != null)
{
var rr = resolver.Resolve(parent);
if (!rr.IsError)
{
return new [] { rr.Type }
}
;
}
var e = parent as EntityDeclaration;
if (e != null)
{
var rt = resolver.Resolve(e.ReturnType);
if (!rt.IsError)
{
return new [] { rt.Type }
}
;
}
}
if (expr.Parent is YieldReturnStatement)
{
var state = resolver.GetResolverStateBefore(expr);
if (state != null && (state.CurrentMember.ReturnType is ParameterizedType))
{
var pt = (ParameterizedType)state.CurrentMember.ReturnType;
if (pt.FullName == "System.Collections.Generic.IEnumerable")
{
return(new [] { pt.TypeArguments.First() });
}
}
}
if (expr.Parent is UnaryOperatorExpression)
{
var uop = (UnaryOperatorExpression)expr.Parent;
switch (uop.Operator)
{
case UnaryOperatorType.Not:
return(new [] { resolver.Compilation.FindType(KnownTypeCode.Boolean) });
case UnaryOperatorType.Minus:
case UnaryOperatorType.Plus:
case UnaryOperatorType.Increment:
case UnaryOperatorType.Decrement:
case UnaryOperatorType.PostIncrement:
case UnaryOperatorType.PostDecrement:
return(new [] { resolver.Compilation.FindType(KnownTypeCode.Int32) });
}
}
if (expr.Parent is ConstructorInitializer)
{
return(GuessFromConstructorInitializer(resolver, expr));
}
if (expr.Parent is NamedExpression)
{
var rr = resolver.Resolve(expr.Parent);
if (!rr.IsError)
{
return(new [] { rr.Type });
}
}
return(Enumerable.Empty <IType>());
}
public ResolveResult Resolve(AstNode node)
{
return(resolver.Resolve(node, cancellationToken));
}
internal static IEnumerable <IType> GetValidTypes(CSharpAstResolver resolver, Expression expr)
{
if (expr.Parent is DirectionExpression)
{
var parent = expr.Parent.Parent;
if (parent is InvocationExpression)
{
var invoke = (InvocationExpression)parent;
return(GetAllValidTypesFromInvokation(resolver, invoke, expr.Parent));
}
}
if (expr.Parent is ObjectCreateExpression)
{
var parent = expr.Parent;
if (parent is ObjectCreateExpression)
{
var invoke = (ObjectCreateExpression)parent;
return(GetAllValidTypesFromObjectCreation(resolver, invoke, expr));
}
}
if (expr.Parent is InvocationExpression)
{
var parent = expr.Parent;
if (parent is InvocationExpression)
{
var invoke = (InvocationExpression)parent;
return(GetAllValidTypesFromInvokation(resolver, invoke, expr));
}
}
if (expr.Parent is VariableInitializer)
{
var initializer = (VariableInitializer)expr.Parent;
return(new [] { resolver.Resolve(initializer).Type });
}
if (expr.Parent is CastExpression)
{
var cast = (CastExpression)expr.Parent;
return(new [] { resolver.Resolve(cast.Type).Type });
}
if (expr.Parent is AsExpression)
{
var cast = (AsExpression)expr.Parent;
return(new [] { resolver.Resolve(cast.Type).Type });
}
if (expr.Parent is AssignmentExpression)
{
var assign = (AssignmentExpression)expr.Parent;
var other = assign.Left == expr ? assign.Right : assign.Left;
return(new [] { resolver.Resolve(other).Type });
}
if (expr.Parent is BinaryOperatorExpression)
{
var assign = (BinaryOperatorExpression)expr.Parent;
var other = assign.Left == expr ? assign.Right : assign.Left;
return(new [] { resolver.Resolve(other).Type });
}
if (expr.Parent is ReturnStatement)
{
var state = resolver.GetResolverStateBefore(expr);
if (state != null)
{
return new [] { state.CurrentMember.ReturnType }
}
;
}
if (expr.Parent is YieldReturnStatement)
{
var state = resolver.GetResolverStateBefore(expr);
if (state != null && (state.CurrentMember.ReturnType is ParameterizedType))
{
var pt = (ParameterizedType)state.CurrentMember.ReturnType;
if (pt.FullName == "System.Collections.Generic.IEnumerable")
{
return(new [] { pt.TypeArguments.First() });
}
}
}
if (expr.Parent is UnaryOperatorExpression)
{
var uop = (UnaryOperatorExpression)expr.Parent;
switch (uop.Operator)
{
case UnaryOperatorType.Not:
return(new [] { resolver.Compilation.FindType(KnownTypeCode.Boolean) });
case UnaryOperatorType.Minus:
case UnaryOperatorType.Plus:
case UnaryOperatorType.Increment:
case UnaryOperatorType.Decrement:
case UnaryOperatorType.PostIncrement:
case UnaryOperatorType.PostDecrement:
return(new [] { resolver.Compilation.FindType(KnownTypeCode.Int32) });
}
}
return(Enumerable.Empty <IType>());
}
protected void HandleExpressionNode(AstNode node)
{
var rr = _resolver.Resolve(node);
VisitResolveResult(rr, null);
}
