本文整理汇总了C#中Compilation.GetSemanticModel方法的典型用法代码示例。如果您正苦于以下问题:C# Compilation.GetSemanticModel方法的具体用法?C# Compilation.GetSemanticModel怎么用?C# Compilation.GetSemanticModel使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Compilation
的用法示例。
在下文中一共展示了Compilation.GetSemanticModel方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: AnalyzeTree
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);
}
}
}
示例2: GetRetroChanges
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;
}
示例3: FixEFModelAsync
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;
}
}
示例4: YieldClassGenerator
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);
}
示例5: AnalyzeTree
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);
}
}
}
示例6: CompileFromAssemblyOfType
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);
}
示例7: CreateSemanticModelFromSource
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);
}
示例8: GetOrCreateCachedSemanticModel
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;
});
}
示例9: CreateFrom
//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;
}
示例10: VerifyCompilation
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();
}
示例11: Compile
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();
}
}
示例12: link
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);
}
示例13: GetOrCreateCachedSemanticModel
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;
}
示例14: Compile
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");
}
}
示例15: Sort
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;
}