示例#1
0
        public static IEnumerable <Diagnostic> BindAndAnalyze(PhpCompilation compilation)
        {
            var manager = compilation.GetBoundReferenceManager();   // ensure the references are resolved! (binds ReferenceManager)

            var diagnostics = new DiagnosticBag();
            var compiler    = new SourceCompiler(compilation, null, true, diagnostics, CancellationToken.None);

            CompilerLogSource.Log.StartPhase(CompilationPhase.Bind.ToString());

            // 1. Bind Syntax & Symbols to Operations (CFG)
            //   a. construct CFG, bind AST to Operation
            //   b. declare table of local variables
            compiler.WalkMethods(compiler.EnqueueRoutine, allowParallel: true);
            compiler.WalkTypes(compiler.EnqueueFieldsInitializer, allowParallel: true);

            CompilerLogSource.Log.StartPhase(CompilationPhase.Analyse.ToString());

            // 2. Analyze Operations
            //   a. type analysis (converge type - mask), resolve symbols
            //   b. lower semantics, update bound tree, repeat
            //   c. collect diagnostics
            compiler.AnalyzeMethods();
            compiler.DiagnoseMethods();
            compiler.DiagnoseTypes();
            compiler.DiagnoseFiles();

            CompilerLogSource.Log.EndPhase();

            //
            return(diagnostics.AsEnumerable());
        }
示例#2
0
        public static IEnumerable <Diagnostic> BindAndAnalyze(PhpCompilation compilation, CancellationToken cancellationToken)
        {
            var manager = compilation.GetBoundReferenceManager();   // ensure the references are resolved! (binds ReferenceManager)

            var diagnostics = new DiagnosticBag();
            var compiler    = new SourceCompiler(compilation, null, true, diagnostics, cancellationToken);

            using (compilation.StartMetric("bind"))
            {
                // 1. Bind Syntax & Symbols to Operations (CFG)
                //   a. construct CFG, bind AST to Operation
                //   b. declare table of local variables
                compiler.WalkMethods(compiler.EnqueueRoutine, allowParallel: true);
                compiler.WalkTypes(compiler.EnqueueFieldsInitializer, allowParallel: true);
            }

            // Repeat analysis and transformation until either the limit is met or there are no more changes
            int transformation = 0;

            do
            {
                // 2. Analyze Operations
                //   a. type analysis (converge type - mask), resolve symbols
                //   b. lower semantics, update bound tree, repeat
                using (compilation.StartMetric("analysis"))
                {
                    compiler.AnalyzeMethods();
                }

                // 3. Resolve operators and types
                using (compilation.StartMetric("bind types"))
                {
                    compiler.BindTypes();
                }

                // 4. Transform Semantic Trees for Runtime Optimization
            } while (
                transformation++ < compiler.MaxTransformCount && // limit number of lowering cycles
                !cancellationToken.IsCancellationRequested &&    // user canceled ?
                compiler.RewriteMethods());                      // try lower the semantics

            // Track the number of actually performed transformations
            compilation.TrackMetric("transformations", transformation - 1);

            // 4. Collect diagnostics
            using (compilation.StartMetric("diagnostic"))
            {
                compiler.DiagnoseMethods();
                compiler.DiagnoseTypes();
                compiler.DiagnoseFiles();
            }

            //
            return(diagnostics.AsEnumerable());
        }
示例#3
0
        public static IEnumerable <Diagnostic> BindAndAnalyze(PhpCompilation compilation)
        {
            var manager = compilation.GetBoundReferenceManager();   // ensure the references are resolved! (binds ReferenceManager)

            var diagnostics = new DiagnosticBag();
            var compiler    = new SourceCompiler(compilation, null, true, diagnostics, CancellationToken.None);

            using (compilation.StartMetric("bind"))
            {
                // 1. Bind Syntax & Symbols to Operations (CFG)
                //   a. construct CFG, bind AST to Operation
                //   b. declare table of local variables
                compiler.WalkMethods(compiler.EnqueueRoutine, allowParallel: true);
                compiler.WalkTypes(compiler.EnqueueFieldsInitializer, allowParallel: true);
            }

            using (compilation.StartMetric("analysis"))
            {
                // 2. Analyze Operations
                //   a. type analysis (converge type - mask), resolve symbols
                //   b. lower semantics, update bound tree, repeat
                //   c. collect diagnostics
                compiler.AnalyzeMethods();
                compiler.DiagnoseMethods();
                compiler.DiagnoseTypes();
                compiler.DiagnoseFiles();
            }

            // TODO: Enable when the rewriting mechanism is refactored
            //if (!diagnostics.HasAnyErrors() && compilation.Options.OptimizationLevel == OptimizationLevel.Release)
            //{
            //    using (compilation.StartMetric("transform"))
            //    {
            //        // 3. Transform Semantic Trees for Runtime Optimization
            //        compiler.TransformMethods();
            //    }
            //}

            //
            return(diagnostics.AsEnumerable());
        }