IType ITypeReference.Resolve(ITypeResolveContext context) { // Strictly speaking, we might have to resolve the type in a nested compilation, similar // to what we're doing with ConstantExpression. // However, in almost all cases this will work correctly - if the resulting type is only available in the // nested compilation and not in this, we wouldn't be able to map it anyways. var ctx = context as CSharpTypeResolveContext; if (ctx == null) { ctx = new CSharpTypeResolveContext(context.CurrentAssembly ?? context.Compilation.MainAssembly, null, context.CurrentTypeDefinition, context.CurrentMember); } return ResolveType(new CSharpResolver(ctx)); // A potential issue might be this scenario: // Assembly 1: // class A { public class Nested {} } // Assembly 2: (references asm 1) // class B : A {} // Assembly 3: (references asm 1 and 2) // class C { public B.Nested Field; } // Assembly 4: (references asm 1 and 3, but not 2): // uses C.Field; // Here we would not be able to resolve 'B.Nested' in the compilation of assembly 4, as type B is missing there. }
public CSharpResolver(CSharpTypeResolveContext context) { if (context == null) throw new ArgumentNullException("context"); this.compilation = context.Compilation; this.conversions = CSharpConversions.Get(compilation); this.context = context; if (context.CurrentTypeDefinition != null) currentTypeDefinitionCache = new TypeDefinitionCache(context.CurrentTypeDefinition); }
private CSharpResolver(ICompilation compilation, CSharpConversions conversions, CSharpTypeResolveContext context, bool checkForOverflow, bool isWithinLambdaExpression, TypeDefinitionCache currentTypeDefinitionCache, ImmutableStack<IVariable> localVariableStack, ObjectInitializerContext objectInitializerStack) { this.compilation = compilation; this.conversions = conversions; this.context = context; this.checkForOverflow = checkForOverflow; this.isWithinLambdaExpression = isWithinLambdaExpression; this.currentTypeDefinitionCache = currentTypeDefinitionCache; this.localVariableStack = localVariableStack; this.objectInitializerStack = objectInitializerStack; }
public CSharpParameterCompletionEngine(IDocument document, ICompletionContextProvider completionContextProvider, IParameterCompletionDataFactory factory, IProjectContent content, CSharpTypeResolveContext ctx) : base (content, completionContextProvider, ctx) { if (document == null) { throw new ArgumentNullException("document"); } if (factory == null) { throw new ArgumentNullException("factory"); } this.document = document; this.factory = factory; }
protected CSharpCompletionEngineBase(IProjectContent content, ICompletionContextProvider completionContextProvider, CSharpTypeResolveContext ctx) { if (content == null) throw new ArgumentNullException("content"); if (ctx == null) throw new ArgumentNullException("ctx"); if (completionContextProvider == null) throw new ArgumentNullException("completionContextProvider"); this.ProjectContent = content; this.CompletionContextProvider = completionContextProvider; this.ctx = ctx; }
public CSharpResolver(ICompilation compilation) { if (compilation == null) throw new ArgumentNullException("compilation"); this.compilation = compilation; this.conversions = CSharpConversions.Get(compilation); this.context = new CSharpTypeResolveContext(compilation.MainAssembly); var pc = compilation.MainAssembly.UnresolvedAssembly as CSharpProjectContent; if (pc != null) { this.checkForOverflow = pc.CompilerSettings.CheckForOverflow; } }
public CSharpCompletionEngine(IDocument document, ICompletionContextProvider completionContextProvider, ICompletionDataFactory factory, IProjectContent content, CSharpTypeResolveContext ctx) : base (content, completionContextProvider, ctx) { if (document == null) { throw new ArgumentNullException("document"); } if (factory == null) { throw new ArgumentNullException("factory"); } this.document = document; this.factory = factory; // Set defaults for additional input properties this.FormattingPolicy = FormattingOptionsFactory.CreateMono(); this.EolMarker = Environment.NewLine; this.IndentString = "\t"; }
public ResolvedUsingScope(CSharpTypeResolveContext context, UsingScope usingScope) { if (context == null) throw new ArgumentNullException("context"); if (usingScope == null) throw new ArgumentNullException("usingScope"); this.parentContext = context; this.usingScope = usingScope; if (usingScope.Parent != null) { if (context.CurrentUsingScope == null) throw new InvalidOperationException(); } else { if (context.CurrentUsingScope != null) throw new InvalidOperationException(); } }
IList<IAttribute> GetAttributes(ref IList<IAttribute> field, bool assemblyAttributes) { IList<IAttribute> result = LazyInit.VolatileRead(ref field); if (result != null) { return result; } else { result = new List<IAttribute>(); foreach (var unresolvedFile in projectContent.Files.OfType<CSharpUnresolvedFile>()) { var attributes = assemblyAttributes ? unresolvedFile.AssemblyAttributes : unresolvedFile.ModuleAttributes; var context = new CSharpTypeResolveContext(this, unresolvedFile.RootUsingScope.Resolve(compilation)); foreach (var unresolvedAttr in attributes) { result.Add(unresolvedAttr.CreateResolvedAttribute(context)); } } return LazyInit.GetOrSet(ref field, result); } }
public override CodeGeneratorMemberResult CreateMemberImplementation (ITypeDefinition implementingType, IUnresolvedTypeDefinition part, IUnresolvedMember member, bool explicitDeclaration) { SetIndentTo (part); var options = new CodeGenerationOptions () { ExplicitDeclaration = explicitDeclaration, ImplementingType = implementingType, Part = part }; ITypeResolveContext ctx; var doc = IdeApp.Workbench.GetDocument (part.Region.FileName); if (doc != null) { ctx = doc.ParsedDocument.GetTypeResolveContext (doc.Compilation, implementingType.Region.Begin); } else { ctx = new CSharpTypeResolveContext (implementingType.Compilation.MainAssembly, null, implementingType, null); } options.Document = doc; if (member is IUnresolvedMethod) return GenerateCode ((IMethod) ((IUnresolvedMethod)member).CreateResolved (ctx), options); if (member is IUnresolvedProperty) return GenerateCode ((IProperty) ((IUnresolvedProperty)member).CreateResolved (ctx), options); if (member is IUnresolvedField) return GenerateCode ((IField) ((IUnresolvedField)member).CreateResolved (ctx), options); if (member is IUnresolvedEvent) return GenerateCode ((IEvent) ((IUnresolvedEvent)member).CreateResolved (ctx), options); throw new NotSupportedException ("member " + member + " is not supported."); }
/// <summary> /// Resolves the namespace represented by this using scope. /// </summary> public ResolvedUsingScope Resolve(ICompilation compilation) { CacheManager cache = compilation.CacheManager; ResolvedUsingScope resolved = cache.GetShared(this) as ResolvedUsingScope; if (resolved == null) { var csContext = new CSharpTypeResolveContext(compilation.MainAssembly, parent != null ? parent.Resolve(compilation) : null); resolved = (ResolvedUsingScope)cache.GetOrAddShared(this, new ResolvedUsingScope(csContext, this)); } return resolved; }
internal static ReachabilityAnalysis Create(Statement statement, Func<AstNode, CancellationToken, ResolveResult> resolver, CSharpTypeResolveContext typeResolveContext, CancellationToken cancellationToken) { var cfgBuilder = new ControlFlowGraphBuilder(); var cfg = cfgBuilder.BuildControlFlowGraph(statement, resolver, typeResolveContext, cancellationToken); return Create(cfg, cancellationToken); }
CSharpResolver WithContext(CSharpTypeResolveContext newContext) { return new CSharpResolver(compilation, conversions, newContext, checkForOverflow, isWithinLambdaExpression, currentTypeDefinitionCache, localVariableStack, objectInitializerStack); }