C# Compilation.GetSemanticModel方法代码示例

 private static void AnalyzeTree(SyntaxTreeAnalysisContext context, Compilation compilation)
 {
     if (context.IsGenerated()) return;
     if (!compilation.SyntaxTrees.Contains(context.Tree)) return;
     var semanticModel = compilation.GetSemanticModel(context.Tree);
     SyntaxNode root;
     if (!context.Tree.TryGetRoot(out root)) return;
     var types = GetTypesInRoot(root);
     foreach (var type in types)
     {
         var fieldDeclarations = type.ChildNodes().OfType<FieldDeclarationSyntax>();
         var variablesToMakeReadonly = GetCandidateVariables(semanticModel, fieldDeclarations);
         var typeSymbol = semanticModel.GetDeclaredSymbol(type);
         if (typeSymbol == null) continue;
         var methods = typeSymbol.GetAllMethodsIncludingFromInnerTypes();
         foreach (var method in methods)
         {
             foreach (var syntaxReference in method.DeclaringSyntaxReferences)
             {
                 var syntaxRefSemanticModel = syntaxReference.SyntaxTree.Equals(context.Tree)
                         ? semanticModel
                         : compilation.GetSemanticModel(syntaxReference.SyntaxTree);
                 var descendants = syntaxReference.GetSyntax().DescendantNodes().ToList();
                 var assignments = descendants.OfKind(SyntaxKind.SimpleAssignmentExpression,
                     SyntaxKind.AddAssignmentExpression, SyntaxKind.AndAssignmentExpression, SyntaxKind.DivideAssignmentExpression,
                     SyntaxKind.ExclusiveOrAssignmentExpression, SyntaxKind.LeftShiftAssignmentExpression, SyntaxKind.ModuloAssignmentExpression,
                     SyntaxKind.MultiplyAssignmentExpression, SyntaxKind.OrAssignmentExpression, SyntaxKind.RightShiftAssignmentExpression,
                     SyntaxKind.SubtractAssignmentExpression);
                 foreach (AssignmentExpressionSyntax assignment in assignments)
                 {
                     var fieldSymbol = syntaxRefSemanticModel.GetSymbolInfo(assignment.Left).Symbol as IFieldSymbol;
                     VerifyVariable(variablesToMakeReadonly, method, syntaxRefSemanticModel, assignment, fieldSymbol);
                 }
                 var postFixUnaries = descendants.OfKind(SyntaxKind.PostIncrementExpression, SyntaxKind.PostDecrementExpression);
                 foreach (PostfixUnaryExpressionSyntax postFixUnary in postFixUnaries)
                 {
                     var fieldSymbol = syntaxRefSemanticModel.GetSymbolInfo(postFixUnary.Operand).Symbol as IFieldSymbol;
                     VerifyVariable(variablesToMakeReadonly, method, syntaxRefSemanticModel, postFixUnary, fieldSymbol);
                 }
                 var preFixUnaries = descendants.OfKind(SyntaxKind.PreDecrementExpression, SyntaxKind.PreIncrementExpression);
                 foreach (PrefixUnaryExpressionSyntax preFixUnary in preFixUnaries)
                 {
                     var fieldSymbol = syntaxRefSemanticModel.GetSymbolInfo(preFixUnary.Operand).Symbol as IFieldSymbol;
                     VerifyVariable(variablesToMakeReadonly, method, syntaxRefSemanticModel, preFixUnary, fieldSymbol);
                 }
             }
         }
         foreach (var readonlyVariable in variablesToMakeReadonly.Values)
         {
             var props = new Dictionary<string, string> { { "identifier", readonlyVariable.Identifier.Text } }.ToImmutableDictionary();
             var diagnostic = Diagnostic.Create(Rule, readonlyVariable.GetLocation(), props, readonlyVariable.Identifier.Text);
             context.ReportDiagnostic(diagnostic);
         }
     }
 }

        private static IDictionary<SyntaxNode, SyntaxNode> GetRetroChanges(Compilation compilation, INamedTypeSymbol objectType)
        {
            var syntaxNodes = new Dictionary<SyntaxNode, SyntaxNode>();

            var semanticModels = compilation.SyntaxTrees.Select(x => compilation.GetSemanticModel(x));

            var genRefs = FindGenericClassMembers(semanticModels);

             //CHANGE
             //1. Generic references with cast
             //2. Generic T to Object
             //======

            foreach (var semanticModel in semanticModels)
            {
                var root = semanticModel.SyntaxTree.GetRoot();

                // get cast changes
                var castReferences = new Dictionary<SyntaxNode, SyntaxNode>();
                CastResursiveMethod(root, semanticModel, genRefs, castReferences);
                
                // get generic T to object
                var retroProperties = GenericToObject(root, semanticModel, objectType);

                var allChanges = castReferences.Concat(retroProperties);

                foreach (var ch in allChanges)
                    syntaxNodes.Add(ch.Key, ch.Value);
            }

            return syntaxNodes;
        }

        private async Task<Solution> FixEFModelAsync(Project project, Compilation compilation,
            IEnumerable<IClassAssumption> classAssumptions, IEnumerable<IPropertyAssumption> propertyAssumptions, ObjectTheoremResult objectTheoremResult,
            CancellationToken cancellationToken)
        {
            Trace.WriteLine("FixEFModelAsync");
            try
            {
                var newSolution = project.Solution;

                foreach (var syntaxTree in compilation.SyntaxTrees)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    var syntaxRoot = await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
                    var semanticModel = compilation.GetSemanticModel(syntaxTree);

                    var rewriter = new AttributeAssumptionsRewriter(semanticModel, classAssumptions, propertyAssumptions, objectTheoremResult, cancellationToken);
                    var newSyntaxRoot = rewriter.Visit(syntaxRoot);

                    cancellationToken.ThrowIfCancellationRequested();

                    var documentId = newSolution.GetDocumentId(syntaxTree);
                    newSolution = newSolution.WithDocumentSyntaxRoot(documentId, newSyntaxRoot);
                }

                return newSolution;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.ToString());
                throw;
            }
        }

        public YieldClassGenerator(Compilation compilation, ClassDeclarationSyntax classDeclarationSyntax, MemberDeclarationSyntax node)
        {
            this.compilation = compilation;
            this.classDeclarationSyntax = classDeclarationSyntax;
            this.node = node;

            method = ModelExtensions.GetDeclaredSymbol(compilation.GetSemanticModel(node.SyntaxTree), node);
        }

 private static void AnalyzeTree(SyntaxTreeAnalysisContext context, Compilation compilation)
 {
     if (context.IsGenerated()) return;
     if (!compilation.SyntaxTrees.Contains(context.Tree)) return;
     var semanticModel = compilation.GetSemanticModel(context.Tree);
     SyntaxNode root;
     if (!context.Tree.TryGetRoot(out root)) return;
     var types = GetTypesInRoot(root);
     foreach (var type in types)
     {
         var fieldDeclarations = type.ChildNodes().OfType<FieldDeclarationSyntax>();
         var variablesToMakeReadonly = GetCandidateVariables(semanticModel, fieldDeclarations);
         var typeSymbol = semanticModel.GetDeclaredSymbol(type);
         if (typeSymbol == null) continue;
         var methods = typeSymbol.GetAllMethodsIncludingFromInnerTypes();
         foreach (var method in methods)
         {
             foreach (var syntaxReference in method.DeclaringSyntaxReferences)
             {
                 var syntaxRefSemanticModel = syntaxReference.SyntaxTree.Equals(context.Tree)
                         ? semanticModel
                         : compilation.GetSemanticModel(syntaxReference.SyntaxTree);
                 var assignments = syntaxReference.GetSyntax().DescendantNodes().OfType<AssignmentExpressionSyntax>();
                 foreach (var assignment in assignments)
                 {
                     var fieldSymbol = syntaxRefSemanticModel.GetSymbolInfo(assignment.Left).Symbol as IFieldSymbol;
                     if (fieldSymbol == null) continue;
                     if (method.MethodKind == MethodKind.StaticConstructor && fieldSymbol.IsStatic)
                         AddVariableThatWasSkippedBeforeBecauseItLackedAInitializer(variablesToMakeReadonly, fieldSymbol, assignment);
                     else if (method.MethodKind == MethodKind.Constructor && !fieldSymbol.IsStatic)
                         AddVariableThatWasSkippedBeforeBecauseItLackedAInitializer(variablesToMakeReadonly, fieldSymbol, assignment);
                     else
                         RemoveVariableThatHasAssignment(variablesToMakeReadonly, fieldSymbol);
                 }
             }
         }
         foreach (var readonlyVariable in variablesToMakeReadonly.Values)
         {
             var props = new Dictionary<string, string> { { "identifier", readonlyVariable.Identifier.Text } }.ToImmutableDictionary();
             var diagnostic = Diagnostic.Create(Rule, readonlyVariable.GetLocation(), props, readonlyVariable.Identifier.Text);
             context.ReportDiagnostic(diagnostic);
         }
     }
 }

 public void CompileFromAssemblyOfType(Type externalType)
 {
     _syntaxTree = CSharpSyntaxTree.ParseText(string.Empty);
     var externalAssembly = MetadataReference.CreateFromFile(externalType.Assembly.Location);
     _compilation = CSharpCompilation.Create(
             "temp",
             syntaxTrees: new[] { _syntaxTree },
             references: new[] { externalAssembly });
     _semanticModel = _compilation.GetSemanticModel(_syntaxTree);
 }

        private void CreateSemanticModelFromSource(IEnumerable<string> fileContent)
        {
            _syntaxTree = CSharpSyntaxTree.ParseText(string.Concat(fileContent));

            _compilation = CSharpCompilation.Create(
                "temp",
                syntaxTrees: new[] { _syntaxTree },
                // add reference to system assembly (for standard data types)
                references: MetaDataReferenceResolver.ResolveSystemAssemblies());
            _semanticModel = _compilation.GetSemanticModel(_syntaxTree);
        }

        public SemanticModel GetOrCreateCachedSemanticModel(SyntaxTree tree, Compilation compilation, CancellationToken cancellationToken)
        {
            return _semanticModelsMap.GetValue(tree,
                t =>
                {
                    var mappedModel = compilation.GetSemanticModel(t);

                    // Invoke GetDiagnostics to populate the compilation's CompilationEvent queue.
                    mappedModel.GetDiagnostics(null, cancellationToken);

                    return mappedModel;
                });
        }

 //protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
 //{
 //   var syntax = syntaxNode as CompilationUnitSyntax;
 //   var newItem = new RDomRoot(syntaxNode, parent, model);
 //   // Root does not call StandardInitialize because the info is attched to the first item
 //   // and particularly, whitespace would be doubled.
 //   //CreateFromWorker.InitializePublicAnnotations(newItem,  syntaxNode,  parent,  model);
 //   newItem.Name = "Root";
 //   CreateFromWorker.LoadStemMembers(newItem, syntax.Members, syntax.Usings, model);
 //   return newItem;
 //}
 //public override IEnumerable<SyntaxNode> BuildSyntax(IDom item)
 //{
 //   var itemAsT = item as IRoot;
 //   var node = SyntaxFactory.CompilationUnit();
 //   var usingsSyntax = itemAsT.UsingDirectives
 //               .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
 //               .ToList();
 //   var membersSyntax = itemAsT.StemMembers
 //               .Where(x => !(x is IUsingDirective))
 //               .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
 //               .ToList();
 //   node = node.WithUsings(SyntaxFactory.List(usingsSyntax));
 //   node = node.WithMembers(SyntaxFactory.List(membersSyntax));
 //   return node.PrepareForBuildSyntaxOutput(item, OutputContext);
 //}
 public IRootGroup CreateFrom(Compilation compilation, bool skipDetail)
 {
     var csharpCompilation = compilation as CSharpCompilation;
      if (csharpCompilation == null) { throw new InvalidOperationException(); }
      var ret = new RDomRootGroup(compilation, _corporation.FactoryAccess);
      foreach (var tree in compilation.SyntaxTrees)
      {
     var model = compilation.GetSemanticModel(tree);
     var root = _corporation.Create(tree.GetCompilationUnitRoot(), null, model).FirstOrDefault() as IRoot;
     ret.Roots.AddOrMove(root);
      }
      return ret;
 }

		private static ImmutableArray<Diagnostic> VerifyCompilation(Compilation compilation)
		{
			var diagnostics = new List<Diagnostic>();

			foreach (var tree in compilation.SyntaxTrees)
			{
				var model = compilation.GetSemanticModel(tree);
				foreach (var node in tree.GetRoot().DescendantNodes(
					_ => true))
				{
					var symbol = model.GetSymbolInfo(node).Symbol;

					if (symbol != null)
					{
						var symbolNamespace = Program.GetFullNamespace(symbol);

						if(symbol.Kind == SymbolKind.Method ||
							symbol.Kind == SymbolKind.Property ||
							symbol.Kind == SymbolKind.NamedType)
						{
							if(symbol.Kind == SymbolKind.Method)
							{
								if (symbolNamespace == typeof(Person).Namespace &&
									symbol.ContainingType.Name == nameof(Person) &&
									symbol.Name == nameof(Person.Save))
								{
									diagnostics.Add(Diagnostic.Create(
										new DiagnosticDescriptor("SCRIPT02", "Persistence Error",
											"Cannot save a person",
											"Usage", DiagnosticSeverity.Error, false),
										node.GetLocation()));
								}
							}

							if (symbolNamespace == "System.IO" ||
								symbolNamespace == "System.Reflection")
							{
								diagnostics.Add(Diagnostic.Create(
									new DiagnosticDescriptor("SCRIPT01", "Inaccessable Member",
										"Cannot allow a member from namespace {0} to be used",
										"Usage", DiagnosticSeverity.Error, false),
									node.GetLocation(), symbolNamespace));
							}
						}
					}
				}
			}

			return diagnostics.ToImmutableArray();
		}

 public void Compile()
 {
     using (var workspace = new AdhocWorkspace())
     {
         var document = workspace.CurrentSolution.AddProject("foo", "foo.dll", LanguageNames.CSharp)
             .AddMetadataReference(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
             .AddMetadataReference(MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location))
             .AddDocument("test", TestInput);
         compilation = document.Project.GetCompilationAsync().Result;
         tree = compilation.SyntaxTrees.First();
         semanticModel = compilation.GetSemanticModel(tree);
         statements = tree.GetRoot().DescendantNodes()
             .OfType<MethodDeclarationSyntax>()
             .First(m => m.Identifier.ValueText == "TestMethod").Body
             .DescendantNodes()
             .OfType<StatementSyntax>().ToList();
     }
 }

        public SyntaxNode link(SyntaxNode node, out Compilation result)
        {
            var           tree  = node.SyntaxTree;
            SemanticModel model = compilation_.GetSemanticModel(node.SyntaxTree);
            node = node.ReplaceNodes(node.GetAnnotatedNodes(Compiler.LinkerAnnotationId), (oldNode, newNode) =>
            {
                var annotation = oldNode.GetAnnotations(Compiler.LinkerAnnotationId).First();
                if (oldNode.SyntaxTree != model.SyntaxTree)
                {
                    oldNode = model.SyntaxTree.GetRoot().GetAnnotatedNodes(Compiler.LinkerAnnotationId).
                                Where(i => i.GetAnnotations(Compiler.LinkerAnnotationId).First().Data == annotation.Data).First();
                }

                return ctx_.Link(oldNode, newNode, annotation.Data, model);
            });

            result = compilation_.ReplaceSyntaxTree(tree, node.SyntaxTree);
            model  = result.GetSemanticModel(node.SyntaxTree);
            return ctx_.ApplyLinkerInfo(node, model, result, out result);
        }

            public SemanticModel GetOrCreateCachedSemanticModel(SyntaxTree tree, Compilation compilation, CancellationToken cancellationToken)
            {
                SemanticModel model;
                lock (_semanticModelsMap)
                {
                    if (_semanticModelsMap.TryGetValue(tree, out model) && model.Compilation == compilation)
                    {
                        return model;
                    }
                }
                
                model = compilation.GetSemanticModel(tree);

                lock (_semanticModelsMap)
                {
                    _semanticModelsMap[tree] = model;
                }

                return model;
            }

        public void Compile()
        {
            using (var workspace = new AdhocWorkspace())
            {
                var document = workspace.CurrentSolution.AddProject("foo", "foo.dll", LanguageNames.CSharp)
                    .AddMetadataReference(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
                    .AddMetadataReference(MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location))
                    .AddDocument("test", SymbolHelperTest.TestInput);
                compilation = document.Project.GetCompilationAsync().Result;
                tree = compilation.SyntaxTrees.First();
                semanticModel = compilation.GetSemanticModel(tree);

                baseClassDeclaration = tree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>()
                    .First(m => m.Identifier.ValueText == "Base");
                derivedClassDeclaration1 = tree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>()
                    .First(m => m.Identifier.ValueText == "Derived1");
                derivedClassDeclaration2 = tree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>()
                    .First(m => m.Identifier.ValueText == "Derived2");
            }
        }

        public static IList<SyntaxTree> Sort(Compilation c, ErrorAggregator aggregator)
        {
            List<SyntaxTreeRelationship> rawList = new List<SyntaxTreeRelationship>();

            foreach (var tree in c.SyntaxTrees)
            {
                SyntaxTreeRelationship relation = new SyntaxTreeRelationship(tree);
                SemanticModel model = c.GetSemanticModel(tree);
                TypeWalker w = new TypeWalker(model, relation);
                w.Visit(tree.GetRoot());
                rawList.Add(relation);
            }

            int max = rawList.Count;

            List<SyntaxTree> sortedList = new List<SyntaxTree>();

            for (int times = 0; times < max; times++)
            {
                for (var i = 0; i < rawList.Count; i++)
                {
                    if (IsIndependent(rawList, i))
                    {
                        sortedList.Add(rawList[i].Tree);
                        rawList.RemoveAt(i);
                    }
                }
            }

            if (rawList.Count > 0)
            {
                CompileIssue issue = CompileIssue.CreateNoLocationIssue(IssueType.Error, IssueId.CrossRef);
                aggregator.AppendIssue(issue);

                //Note:use original order. use sortedList will miss cross ref class.
                return rawList.ConvertAll(r => r.Tree);
            }

            return sortedList;
        }