public ICodeContext ResolveContext(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken)
{
var csParseInfo = parseInfo as CSharpFullParseInformation;
if (csParseInfo == null)
{
throw new ArgumentException("Parse info does not have SyntaxTree");
}
CSharpUnresolvedFile unresolvedFile = csParseInfo.UnresolvedFile;
var projectContents = compilation.Assemblies.Select(asm => asm.UnresolvedAssembly).OfType <IProjectContent>().ToList();
if (projectContents.All(pc => pc.GetFile(unresolvedFile.FileName) != unresolvedFile))
{
unresolvedFile = null;
}
var syntaxTree = csParseInfo.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, unresolvedFile);
return(resolver.GetResolverStateBefore(node));
}
// Token: 0x06000012 RID: 18 RVA: 0x0000243C File Offset: 0x0000063C
private ResolveResult GetLanguageItem(ProjectDocument doc, string expression, Client.SourceLocation location)
{
ParsedDocument parsedDocument = doc.ParsedDocument;
if (parsedDocument == null)
{
return(null);
}
SyntaxTree ast = parsedDocument.GetAst <SyntaxTree>();
CSharpUnresolvedFile csharpUnresolvedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (ast == null || csharpUnresolvedFile == null)
{
return(null);
}
AstNode nodeAt = ast.GetNodeAt(location.Line, location.Column, null);
if (nodeAt == null)
{
return(null);
}
CSharpTypeResolveContext typeResolveContext = csharpUnresolvedFile.GetTypeResolveContext(doc.Compilation, new TextLocation(location.Line, location.Column));
CSharpResolver resolver = new CSharpResolver(typeResolveContext);
CSharpAstResolver csharpAstResolver = new CSharpAstResolver(resolver, ast, csharpUnresolvedFile);
csharpAstResolver.ApplyNavigator(new NodeListResolveVisitorNavigator(new AstNode[]
{
nodeAt
}), CancellationToken.None);
CSharpResolver resolverStateBefore = csharpAstResolver.GetResolverStateBefore(nodeAt, CancellationToken.None);
return(resolverStateBefore.LookupSimpleNameOrTypeName(expression, new List <IType>(), NameLookupMode.Expression));
}
public CodeGenerationOptions()
{
currentState = new Lazy <CSharpResolver> (() => {
var parsedDocument = Document.ParsedDocument;
if (parsedDocument == null)
{
return(null);
}
var unit = parsedDocument.GetAst <SyntaxTree> ().Clone();
var file = parsedDocument.ParsedFile as CSharpUnresolvedFile;
var resolvedNode = unit.GetNodeAt <BlockStatement> (Document.Editor.Caret.Location);
if (resolvedNode == null)
{
return(null);
}
var expr = new IdentifierExpression("foo");
resolvedNode.Add(expr);
var ctx = file.GetTypeResolveContext(Document.Compilation, Document.Editor.Caret.Location);
var resolver = new CSharpResolver(ctx);
var astResolver = new CSharpAstResolver(resolver, unit, file);
astResolver.ApplyNavigator(new NodeListResolveVisitorNavigator(expr), CancellationToken.None);
astResolver.Resolve(expr);
return(astResolver.GetResolverStateBefore(expr));
});
}
protected Tuple <ResolveResult, CSharpResolver> ResolveExpression(CSharpParsedFile file, 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;
}
// var newContent = ProjectContent.UpdateProjectContent (CSharpParsedFile, file);
var csResolver = new CSharpAstResolver(new CSharpResolver(ctx), unit, CSharpParsedFile);
var result = csResolver.Resolve(resolveNode);
var state = csResolver.GetResolverStateBefore(resolveNode);
return(Tuple.Create(result, state));
}
public override AstType CreateShortType(IType fullType)
{
CSharpResolver csResolver;
lock (resolver) {
csResolver = resolver.GetResolverStateBefore(GetNode());
}
var builder = new TypeSystemAstBuilder(csResolver);
return(builder.ConvertType(fullType));
}
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));
}
void HandleConstructorOrDestructor(AstNode constructorDeclaration)
{
Identifier nameToken = constructorDeclaration.GetChildByRole(Roles.Identifier);
VisitChildrenUntil(constructorDeclaration, nameToken);
var currentTypeDef = resolver.GetResolverStateBefore(constructorDeclaration).CurrentTypeDefinition;
if (currentTypeDef != null && nameToken.Name == currentTypeDef.Name)
{
TColor color;
if (TryGetTypeHighlighting(currentTypeDef.Kind, out color))
{
Colorize(nameToken, color);
}
}
VisitChildrenAfter(constructorDeclaration, nameToken);
}
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 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);
return(state.LookupSimpleNameOrTypeName(expression, new List <IType> (), NameLookupMode.Expression));
}
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);
}
}
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>());
}
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 CSharpResolver GetResolverStateBefore(AstNode node)
{
return(resolver.GetResolverStateBefore(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>());
}
