public void Compile() { if (_compilation == null) { ImmutableModel coreModel = MetaInstance.MModel; string text = File.ReadAllText(_inputFilePath); var tree = MetaSyntaxTree.ParseText(text, path: _inputFilePath); BinderFlags binderFlags = BinderFlags.IgnoreAccessibility; if (_compileMetaModelCore) { BinderFlags binderFlags2 = BinderFlags.IgnoreMetaLibraryDuplicatedTypes; binderFlags = binderFlags.UnionWith(binderFlags2); } MetaCompilationOptions options = new MetaCompilationOptions(MetaLanguage.Instance, OutputKind.NetModule, deterministic: true, concurrentBuild: true, topLevelBinderFlags: binderFlags); //MetaCompilationOptions options = new MetaCompilationOptions(MetaLanguage.Instance, OutputKind.NetModule, deterministic: true, concurrentBuild: false); var compilation = MetaCompilation. Create("MetaModelCompilation"). AddSyntaxTrees(tree). AddReferences( ModelReference.CreateFromModel(coreModel) ). WithOptions(options); Interlocked.CompareExchange(ref _compilation, compilation, null); } _compilation.ForceComplete(); }
/// <summary> /// Creates a new compilation from scratch. Methods such as AddSyntaxTrees or AddReferences /// on the returned object will allow to continue building up the Compilation incrementally. /// </summary> /// <param name="assemblyName">Simple assembly name.</param> /// <param name="syntaxTrees">The syntax trees with the source code for the new compilation.</param> /// <param name="references">The references for the new compilation.</param> /// <param name="options">The compiler options to use.</param> /// <returns>A new compilation.</returns> public static MetaCompilation Create( string assemblyName, IEnumerable <SyntaxTree> syntaxTrees = null, IEnumerable <MetadataReference> references = null, MetaCompilationOptions options = null) { return(Create( assemblyName, options ?? s_defaultOptions, syntaxTrees, references, previousSubmission: null, returnType: null, hostObjectType: null, isSubmission: false)); }
/// <summary> /// Creates a new compilation that can be used in scripting. /// </summary> public static MetaCompilation CreateScriptCompilation( string assemblyName, SyntaxTree syntaxTree = null, IEnumerable <MetadataReference> references = null, MetaCompilationOptions options = null, MetaCompilation previousScriptCompilation = null, Type returnType = null, Type globalsType = null) { CheckSubmissionOptions(options); ValidateScriptCompilationParameters(previousScriptCompilation, returnType, ref globalsType); return(Create( assemblyName, options?.WithReferencesSupersedeLowerVersions(true) ?? s_defaultSubmissionOptions, (syntaxTree != null) ? new[] { syntaxTree } : NoSyntaxTrees, references, previousScriptCompilation, returnType, globalsType, isSubmission: true)); }
private static MetaCompilation Create( string assemblyName, MetaCompilationOptions options, IEnumerable <SyntaxTree> syntaxTrees, IEnumerable <MetadataReference> references, MetaCompilation previousSubmission, Type returnType, Type hostObjectType, bool isSubmission) { Debug.Assert(options != null); Debug.Assert(!isSubmission || options.ReferencesSupersedeLowerVersions); var compilation = new MetaCompilation( assemblyName, options, references, previousSubmission, returnType, hostObjectType, isSubmission, referenceManager: null, reuseReferenceManager: false, syntaxAndDeclarations: new SyntaxAndDeclarationManager( ImmutableArray <SyntaxTree> .Empty, options.ScriptClassName, options.SourceReferenceResolver, options.Language, isSubmission, state: null)); if (syntaxTrees != null) { compilation = compilation.AddSyntaxTrees(syntaxTrees); } return(compilation); }
/// <summary> /// Creates a new compilation with the specified compilation options. /// </summary> public MetaCompilation WithOptions(MetaCompilationOptions options) => (MetaCompilation)base.WithOptions(options);
protected MetaCompilation(string assemblyName, MetaCompilationOptions options, IEnumerable <MetadataReference> references, MetaCompilation previousSubmission, Type submissionReturnType, Type hostObjectType, bool isSubmission, ReferenceManager referenceManager, bool reuseReferenceManager, SyntaxAndDeclarationManager syntaxAndDeclarations, AsyncQueue <CompilationEvent> eventQueue = null) : base(assemblyName, options, references, previousSubmission, submissionReturnType, hostObjectType, isSubmission, referenceManager, reuseReferenceManager, syntaxAndDeclarations, eventQueue) { }
public bool Equals(MetaCompilationOptions other) { return(base.Equals(other)); }