private static void PrintMethodContentViaSemanticModel(SyntaxTree tree) { Console.Out.WriteLine(nameof(Program.PrintMethodContentViaSemanticModel)); var compilation = CSharpCompilation.Create( "MethodContent", syntaxTrees: new[] { tree }, references: new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) }); var model = compilation.GetSemanticModel(tree, true); var methods = tree.GetRoot().DescendantNodes(_ => true) .OfType<MethodDeclarationSyntax>(); foreach (var method in methods) { var methodInfo = model.GetDeclaredSymbol(method) as IMethodSymbol; var parameters = new List<string>(); foreach (var parameter in methodInfo.Parameters) { var isRef = parameter.RefKind == RefKind.Ref ? "ref " : string.Empty; parameters.Add($"{isRef}{parameter.Type.Name} {parameter.Name}"); } Console.Out.WriteLine( $"{methodInfo.Name}({string.Join(", ", parameters)})"); } }
public static void DumpSyntaxTree(SyntaxTree syntaxTree, string declarationFilter, string description) { if (syntaxTree != null) { PanelManager.DisplayControl(new SyntaxTreePanel(syntaxTree, declarationFilter), description ?? "Syntax Tree"); } }
public AbstractIndenter( ISyntaxFactsService syntaxFacts, SyntaxTree syntaxTree, IEnumerable<IFormattingRule> rules, OptionSet optionSet, TextLine lineToBeIndented, CancellationToken cancellationToken) { var syntaxRoot = syntaxTree.GetRoot(cancellationToken); this._syntaxFacts = syntaxFacts; this.OptionSet = optionSet; this.Tree = syntaxTree; this.LineToBeIndented = lineToBeIndented; this.TabSize = this.OptionSet.GetOption(FormattingOptions.TabSize, syntaxRoot.Language); this.CancellationToken = cancellationToken; this.Rules = rules; this.Finder = new BottomUpBaseIndentationFinder( new ChainedFormattingRules(this.Rules, OptionSet), this.TabSize, this.OptionSet.GetOption(FormattingOptions.IndentationSize, syntaxRoot.Language), tokenStream: null, lastToken: default(SyntaxToken)); }
protected override AbstractIndenter GetIndenter( ISyntaxFactsService syntaxFacts, SyntaxTree syntaxTree, TextLine lineToBeIndented, IEnumerable<IFormattingRule> formattingRules, OptionSet optionSet, CancellationToken cancellationToken) { return new Indenter( syntaxFacts, syntaxTree, formattingRules, optionSet, lineToBeIndented, cancellationToken); }
public static SemanticModel GetSemanticModel(SyntaxTree tree, string extDll) { var Mscorlib = PortableExecutableReference.CreateFromFile(typeof(object).Assembly.Location); var current = PortableExecutableReference.CreateFromFile(Assembly.GetExecutingAssembly().Location); var current2 = PortableExecutableReference.CreateFromFile(typeof(Hide).Assembly.Location); var current3 = PortableExecutableReference.CreateFromFile(extDll); var current4 = PortableExecutableReference.CreateFromFile(@"D:\ghostnguyen\daccf960-44f9-4f95-91c4-b1aba37effe1\packages\Microsoft.AspNet.Mvc.5.2.3\lib\net45\System.Web.Mvc.dll"); var current5 = PortableExecutableReference.CreateFromFile(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Web.dll"); var current6 = PortableExecutableReference.CreateFromFile(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Xml.Linq.dll"); var current7 = PortableExecutableReference.CreateFromFile(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Xml.dll"); var current8 = PortableExecutableReference.CreateFromFile(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Core.dll"); var current9 = PortableExecutableReference.CreateFromFile(@"D:\ghostnguyen\daccf960-44f9-4f95-91c4-b1aba37effe1\packages\Microsoft.AspNet.WebApi.Core.5.2.3\lib\net45\System.Web.Http.dll"); var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { Mscorlib, current, current2, current3, current4, current5, current6, current7, current8, current9 }); var model = compilation.GetSemanticModel(tree); var dia1 = model.GetDiagnostics(); var dia2 = compilation.GetDiagnostics(); return model; }
public static IEnumerable<PropertyDeclarationSyntax> GetProperties(SyntaxTree syntaxTree) { var result = syntaxTree.GetRoot().DescendantNodes() .Where(node => node.IsKind(SyntaxKind.PropertyDeclaration)) .Cast<PropertyDeclarationSyntax>(); return result; }
internal CodeProvider(SyntaxTree tree, Compilation compilation) { this.SyntaxTree = tree; //project.GetCompilationAsync().Result; this.Compilation = compilation; this.SemanticModel = this.Compilation.GetSemanticModel(tree); }
public int? FromIndentBlockOperations( SyntaxTree tree, SyntaxToken token, int position, CancellationToken cancellationToken) { // we use operation service to see whether it is a starting point of new indentation. // ex) // if (true) // { // | <= this is new starting point of new indentation var operation = GetIndentationDataFor(tree.GetRoot(cancellationToken), token, position); // try find indentation based on indentation operation if (operation != null) { // make sure we found new starting point of new indentation. // such operation should start span after the token (a token that is right before the new indentation), // contains current position, and position should be before the existing next token if (token.Span.End <= operation.TextSpan.Start && operation.TextSpan.IntersectsWith(position) && position <= token.GetNextToken(includeZeroWidth: true).SpanStart) { return GetIndentationOfCurrentPosition(tree, token, position, cancellationToken); } } return null; }
protected SyntacticDocument(Document document, SourceText text, SyntaxTree tree, SyntaxNode root) { this.Document = document; this.Text = text; this.SyntaxTree = tree; this.Root = root; }
private static IEnumerable<Conflict> GetConflicts(IEnumerable<Diff> local, IEnumerable<Diff> remote, SyntaxTree ancestorTree, SyntaxTree localTree, SyntaxTree remoteTree) { var localChanges = local.Select(DiffWithOrigin.Local); var remoteChanges = remote.Select(DiffWithOrigin.Remote); var changes = Extensions.GetMergedQueue(localChanges, remoteChanges, d => d.Diff.Ancestor.Span.Start); var potentialConflict = new List<DiffWithOrigin>(); while (changes.Count > 0) { potentialConflict.Clear(); do { var change = changes.Dequeue(); potentialConflict.Add(change); } while (changes.Count > 0 && Diff.IntersectsAny(changes.Peek().Diff, potentialConflict.Select(dwo => dwo.Diff))); if (potentialConflict.Count >= 2) yield return Conflict.Create(potentialConflict, ancestorTree, localTree, remoteTree); } yield break; }
private static void OneSide(Repo repo, SyntaxTree local, SyntaxTree remote, SyntaxTree ancestor, string path) { //Fake a call te to GetRemoteChange() by placeing the remote and ancestor trees into the RemoteChangesData list repo.PullRequests.Clear(); repo.PullRequests.Add(new PullRequest { Updated = DateTime.Now, Files = new[] { new Core.RepoFile { BaseTree = ancestor, HeadTree = remote, Filename = path, Status = RepoFile.StatusEnum.Modified, } }, Title = "Fake Pull Request", Url = "http://github.com/example/repo", Number = 1, State = "open", LastWrite = DateTime.MinValue, Base = new PullRequest.HeadBase { Sha = "" }, Head = new PullRequest.HeadBase { Sha = "" }, }); var pr = repo.PullRequests.First(); pr.ParentRepo = repo; pr.ValidFiles.First().ParentPullRequst = pr; var res = Analysis.ForFalsePositive(repo, local); Assert.IsTrue(res.Any()); }
public static bool IsEntirelyWithinStringLiteral( SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) { var token = syntaxTree.GetRoot(cancellationToken).FindToken(position, findInsideTrivia: true); // If we ask right at the end of the file, we'll get back nothing. We handle that case // specially for now, though SyntaxTree.FindToken should work at the end of a file. if (IsKind(token, SyntaxKind.EndOfDirectiveToken, SyntaxKind.EndOfFileToken)) { token = token.GetPreviousToken(includeSkipped: true, includeDirectives: true); } if (token.IsKind(SyntaxKind.StringLiteralToken)) { var span = token.Span; // cases: // "|" // "| (e.g. incomplete string literal) return (position > span.Start && position < span.End) || AtEndOfIncompleteStringOrCharLiteral(token, position, '"'); } if (IsKind(token, SyntaxKind.InterpolatedStringStartToken, SyntaxKind.InterpolatedStringTextToken, SyntaxKind.InterpolatedStringEndToken)) { return token.SpanStart < position && token.Span.End > position; } return false; }
public Microsoft.CodeAnalysis.SyntaxTree Translate(VSGraphModel graphModel, CompilationOptions options) { Profiler.BeginSample("Translation"); Microsoft.CodeAnalysis.SyntaxTree syntaxTree = ToSyntaxTree(graphModel, options); Profiler.EndSample(); return(syntaxTree); }
internal static Compilation CreateCompilation(SyntaxTree tree) { var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { mscorlib }); return compilation; }
public Assembly Compile(string guid, string text, params Assembly[] referencedAssemblies) { //return CSScript.Evaluator.ReferenceAssembly(Assembly.GetExecutingAssembly()).CompileCode(text,new CompileInfo() { RootClass = "tet", PreferLoadingFromFile=true }); Logger.LogDebug("Compiler", $"Compiler cout is{referencedAssemblies.Length}"); var references = referencedAssemblies.Select(it => Microsoft.CodeAnalysis.MetadataReference .CreateFromFile(it.Location)); var options = new CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary); var assemblyName = guid;// "_" + Guid.NewGuid().ToString("D"); var syntaxTrees = new Microsoft.CodeAnalysis.SyntaxTree[] { CSharpSyntaxTree.ParseText(text) }; var compilation = CSharpCompilation.Create( assemblyName, syntaxTrees, references, options); using var stream = new MemoryStream(); var compilationResult = compilation.Emit(stream); if (compilationResult.Success) { stream.Seek(0, SeekOrigin.Begin); return(Assembly.Load(stream.ToArray())); } else { var allerrro = new StringBuilder(); var i = 1; foreach (var item in compilationResult.Diagnostics) { allerrro.AppendFormat("{0}-->Info:{1}\r\n=================================\r\n", i, item.ToString()); i++; } throw new InvalidOperationException($"Compilation error;\r\n{ allerrro.ToString()}"); } }
/// <summary> /// Rewrites the syntax tree with create machine expressions. /// </summary> /// <param name="tree">SyntaxTree</param> /// <returns>SyntaxTree</returns> internal SyntaxTree Rewrite(SyntaxTree tree) { var statements = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>(). Where(val => val.Expression is IdentifierNameSyntax). Where(val => (val.Expression as IdentifierNameSyntax).Identifier.ValueText.Equals("create")). ToList(); if (statements.Count == 0) { return tree; } var root = tree.GetRoot().ReplaceNodes( nodes: statements, computeReplacementNode: (node, rewritten) => this.RewriteStatement(rewritten)); var models = root.DescendantNodes(). Where(val => val is LocalDeclarationStatementSyntax). Where(val => this.ToReplace.Any(n => n.IsEquivalentTo(val))); root = root.ReplaceNodes( nodes: models, computeReplacementNode: (node, rewritten) => SyntaxFactory.ParseStatement(";")); root = root.RemoveNodes(this.ToRemove, SyntaxRemoveOptions.KeepNoTrivia); return base.UpdateSyntaxTree(tree, root.ToString()); }
private Compilation CompileScript(Microsoft.CodeAnalysis.SyntaxTree tree, OptimizationLevel level) { var references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(Object).Assembly.Location), MetadataReference.CreateFromFile(typeof(Console).Assembly.Location), MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location), }; var all = references.Concat(GetReferences()); var usings = GetUsings(); var options = ScriptOptions.Default .WithImports(usings) .WithReferences(references); var script = CSharpScript.Create(tree.ToString(), options); var com = script.GetCompilation(); if (level == OptimizationLevel.Release) { SetReleaseOptimizationLevel(com); } return(com); }
/// <summary> /// Get assembly from the given text. /// </summary> /// <param name="tree">SyntaxTree</param> /// <returns>Assembly</returns> protected Assembly GetAssembly(SyntaxTree tree) { Assembly assembly = null; var references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location), MetadataReference.CreateFromFile(typeof(Machine).Assembly.Location), MetadataReference.CreateFromFile(typeof(PSharpBugFindingRuntime).Assembly.Location) }; var compilation = CSharpCompilation.Create( "PSharpTestAssembly", new[] { tree }, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var ms = new MemoryStream()) { var result = compilation.Emit(ms); if (result.Success) { ms.Seek(0, SeekOrigin.Begin); assembly = Assembly.Load(ms.ToArray()); } } return assembly; }
public CSharpCompilation GetCompilation(string assemblyName, IDictionary<string, string> files, out SyntaxTree[] trees) { var options = new CSharpParseOptions(_languageVersion); trees = files.Select(x => { var text = x.Value; var tree = CSharpSyntaxTree.ParseText(text, options: options); if (tree.GetDiagnostics().Any()) throw new Exception(string.Format("Syntax error in file \"{0}\".", x.Key)); return tree; }).ToArray(); // adding everything is going to cause issues with dynamic assemblies // so we would want to filter them anyway... but we don't need them really //var refs = AssemblyUtility.GetAllReferencedAssemblyLocations().Select(x => new MetadataFileReference(x)); // though that one is not ok either since we want our own reference //var refs = Enumerable.Empty<MetadataReference>(); // so use the bare minimum var asms = ReferencedAssemblies; var a1 = typeof(Builder).Assembly; asms.Add(a1); foreach (var a in GetDeepReferencedAssemblies(a1)) asms.Add(a); var refs = asms.Select(x => MetadataReference.CreateFromFile(x.Location)); var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); var compilation = CSharpCompilation.Create( assemblyName, /*syntaxTrees:*/ trees, /*references:*/ refs, compilationOptions); return compilation; }
public IEnumerable<AttributeListSyntax> GetAttributeListsNodes(SyntaxTree syntaxTree) { if (syntaxTree == null) throw new ArgumentNullException(nameof(syntaxTree)); return syntaxTree.GetRoot() .DescendantNodes() .OfType<AttributeListSyntax>(); }
static CompilationResult CheckSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree, CompilationResult compilationResult) { SemanticModel semanticModel = GetSemanticModel(syntaxTree); // run all the semantic code analyzers var diagnostics = new List <CompilerError>(); Profiler.BeginSample("GetDiagnostics"); ImmutableArray <Diagnostic> rawDiagnostics = semanticModel.GetDiagnostics(); Profiler.EndSample(); Profiler.BeginSample("ProcessDiagnostics"); ProcessDiagnostics(rawDiagnostics, diagnostics); Profiler.EndSample(); Profiler.BeginSample("Format"); var codeText = syntaxTree.GetText().ToString(); compilationResult.sourceCode[(int)SourceCodePhases.Final] = codeText; Profiler.EndSample(); if (diagnostics.Any()) { compilationResult.errors = diagnostics; } return(compilationResult); }
public IEnumerable<Match> Run(SyntaxTree tree) { return tree.GetRoot() .DescendantNodesAndTokensAndSelf() .Select(CreateMatch) .Where(n => n.IsMatch); }
/// <summary> /// Rewrites the syntax tree with raise statements. /// </summary> /// <param name="tree">SyntaxTree</param> /// <returns>SyntaxTree</returns> internal SyntaxTree Rewrite(SyntaxTree tree) { var statements = tree.GetRoot().DescendantNodes().OfType<ExpressionStatementSyntax>(). Where(val => val.Expression is InvocationExpressionSyntax). Where(val => (val.Expression as InvocationExpressionSyntax).Expression is IdentifierNameSyntax). Where(val => ((val.Expression as InvocationExpressionSyntax).Expression as IdentifierNameSyntax). Identifier.ValueText.Equals("raise")). ToList(); if (statements.Count == 0) { return tree; } var root = tree.GetRoot().ReplaceNodes( nodes: statements, computeReplacementNode: (node, rewritten) => this.RewriteStatement(rewritten)); var raiseStmts = root.DescendantNodes().OfType<ExpressionStatementSyntax>(). Where(val => this.RaiseStmts.Any(v => SyntaxFactory.AreEquivalent(v, val))).ToList(); foreach (var stmt in raiseStmts) { root = root.InsertNodesAfter(stmt, new List<SyntaxNode> { this.CreateReturnStatement() }); } return base.UpdateSyntaxTree(tree, root.ToString()); }
/// <summary> /// Creates a fresh new compilation of source files. /// Does not load any assembly. /// </summary> /// <returns>Success if no compilation erros were encountered.</returns> public bool Compile() { if (SourceFiles.Count == 0 && SourceTexts.Count == 0) return false; SyntaxTree [] syntaxTrees = new SyntaxTree[SourceFiles.Count + SourceTexts.Count]; int currentIndex = 0; try { foreach (string sourceFile in SourceFiles) { using (StreamReader reader = new StreamReader(MyFileSystem.OpenRead(sourceFile))) { var text = reader.ReadToEnd(); syntaxTrees[currentIndex] = CSharpSyntaxTree.ParseText(text); currentIndex++; } } foreach (var sourceText in SourceTexts) syntaxTrees[currentIndex++] = CSharpSyntaxTree.ParseText(sourceText); m_compilation = CSharpCompilation.Create(AssemblyName, syntaxTrees, DependencyCollector.References, m_defaultCompilationOptions); } catch (Exception e) { Debug.Fail(e.ToString()); return false; } return true; }
public StatMachineGeneratorFixer(Compilation compilation, SyntaxTree syntaxTree, SemanticModel semanticModel, string enclosingTypeName) { this.compilation = compilation; this.syntaxTree = syntaxTree; this.semanticModel = semanticModel; this.enclosingTypeName = enclosingTypeName; }
public SourceWithMarkedNodes(string markedSource, Func<string, SyntaxTree> parser, Func<string, int> getSyntaxKind) { Source = ClearTags(markedSource); Tree = parser(Source); SpansAndKindsAndIds = ImmutableArray.CreateRange(GetSpansRecursive(markedSource, 0, getSyntaxKind)); }
public void TestSetup() { syntaxTree = CSharpSyntaxTree.ParseText(Source); ifMethod = syntaxTree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().First(m => m.Identifier.ValueText == "IfMethod"); switchMethod = syntaxTree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().First(m => m.Identifier.ValueText == "SwitchMethod"); }
/// <summary> /// Rewrites the syntax tree with raise statements. /// </summary> /// <param name="tree">SyntaxTree</param> /// <returns>SyntaxTree</returns> internal SyntaxTree Rewrite(SyntaxTree tree) { var stmts1 = tree.GetRoot().DescendantNodes().OfType<ExpressionStatementSyntax>(). Where(val => val.Expression is InvocationExpressionSyntax). Where(val => (val.Expression as InvocationExpressionSyntax).Expression is IdentifierNameSyntax). Where(val => ((val.Expression as InvocationExpressionSyntax).Expression as IdentifierNameSyntax). Identifier.ValueText.Equals("Raise")). ToList(); var stmts2 = tree.GetRoot().DescendantNodes().OfType<ExpressionStatementSyntax>(). Where(val => val.Expression is InvocationExpressionSyntax). Where(val => (val.Expression as InvocationExpressionSyntax).Expression is MemberAccessExpressionSyntax). Where(val => ((val.Expression as InvocationExpressionSyntax).Expression as MemberAccessExpressionSyntax). Name.Identifier.ValueText.Equals("Raise")). ToList(); var statements = stmts1; statements.AddRange(stmts2); if (statements.Count == 0) { return tree; } var root = tree.GetRoot().ReplaceNodes( nodes: statements, computeReplacementNode: (node, rewritten) => this.RewriteStatement(rewritten)); return base.UpdateSyntaxTree(tree, root.ToString()); }
public static bool IsExercise(SyntaxTree tree) { return tree.GetRoot() .DescendantNodes() .OfType<MethodDeclarationSyntax>() .Any(m => m.HasAttribute<ExpectedOutputAttribute>()); }
public Checker(Stream file) { using (var reader = new StreamReader(file, Encoding.UTF8, true, 16 * 1024, true)) { _tree = CSharpSyntaxTree.ParseText(reader.ReadToEnd(), options: ParseOptions); } }
protected override Compilation CreateCompilation(SyntaxTree syntaxTree, string assemblyName, IEnumerable<PortableExecutableReference> references) { return VisualBasicCompilation.Create( assemblyName, syntaxTrees: new[] { syntaxTree }, references: references, options: new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); }
private Boolean IsAutoGenerated(SyntaxTree tree) => tree.GetRoot() .GetLeadingTrivia() .Where(t => t.IsKind(SyntaxKind.SingleLineCommentTrivia) && t.ToString().IndexOf("<auto-generated>", StringComparison.OrdinalIgnoreCase) != -1 ) .Any();
internal static Compilation CreateCompilation(SyntaxTree tree) { var mscorlibAssembly = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var debugAssembly = MetadataReference.CreateFromFile(typeof(System.Diagnostics.Debug).Assembly.Location); var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { mscorlibAssembly, debugAssembly }, options: new CSharpCompilationOptions(outputKind: OutputKind.DynamicallyLinkedLibrary)); return compilation; }
/// <summary> /// Normalizes the <paramref name="syntaxTree" /> of the <see cref="Compilation" />. /// </summary> /// <param name="syntaxTree">The syntax tree that should be normalized.</param> protected override SyntaxTree Normalize(SyntaxTree syntaxTree) { var root = syntaxTree.GetRoot(); var firstNode = root.GetFirstToken(true, true, true, true).Parent; var updatedNode = firstNode.PrependLineDirective(1, syntaxTree.FilePath); return syntaxTree.WithFilePath(syntaxTree.FilePath + Guid.NewGuid()).WithRoot(root.ReplaceNode(firstNode, updatedNode)); }
public static List <string> GetMethodParams(string scriptCode, int position, ILogger log = null) { //position = position - 2; List <string> overloads = new List <string>(); var meta = AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES"); string[] assembliesNames = meta.ToString().Split(';', StringSplitOptions.None); var sourceLanguage = new CSharpLanguage(); //SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(scriptCode); SyntaxTree syntaxTree = sourceLanguage.ParseText(scriptCode, SourceCodeKind.Script); var root = (CompilationUnitSyntax)syntaxTree.GetRoot(); var thisAssembly = typeof(CompleteCode).Assembly; var loadContext = AssemblyLoadContext.GetLoadContext(thisAssembly); var Mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { syntaxTree }, references: CompileResources.PortableExecutableCompletionReferences); var model = compilation.GetSemanticModel(syntaxTree); var theToken = syntaxTree.GetRoot().FindToken(position); var theNode = theToken.Parent; while (!theNode.IsKind(SyntaxKind.InvocationExpression)) { theNode = theNode.Parent; if (theNode == null) { break; // There isn't an InvocationExpression in this branch of the tree } } if (theNode == null) { overloads = null; } else { var symbolInfo = model.GetSymbolInfo(theNode); var symbol = symbolInfo.Symbol; var containingType = symbol?.ContainingType; if (symbolInfo.CandidateSymbols != default && symbolInfo.CandidateSymbols.Length > 0) { foreach (var parameters in symbolInfo.CandidateSymbols) { var i = parameters.ToMinimalDisplayParts(model, position); if (parameters.Kind == SymbolKind.Method) { var mp = parameters.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat); overloads.Add(mp); } } } } return(overloads); }
public Microsoft.CodeAnalysis.SyntaxTree Translate(VSGraphModel graphModel, CompilationOptions options) { Profiler.BeginSample("Translation"); Microsoft.CodeAnalysis.SyntaxTree syntaxTree = ToSyntaxTree(graphModel, options); Profiler.EndSample(); var compilationResult = new CompilationResult(); ApplyPluginsToAst(ref syntaxTree, options, graphModel.Stencil, ref compilationResult); return(syntaxTree); }
public void Compile() { Profiler.BeginSample("UdonSharp Compile"); System.Diagnostics.Stopwatch compileTimer = new System.Diagnostics.Stopwatch(); compileTimer.Start(); int totalErrorCount = 0; try { EditorUtility.DisplayProgressBar("UdonSharp Compile", "Parsing Syntax Trees...", 0f); UdonSharpProgramAsset[] allPrograms = UdonSharpProgramAsset.GetAllUdonSharpPrograms(); List <(UdonSharpProgramAsset, string)> programAssetsAndPaths = new List <(UdonSharpProgramAsset, string)>(); foreach (UdonSharpProgramAsset programAsset in allPrograms) { if (programAsset == null || programAsset.sourceCsScript == null) { continue; } programAssetsAndPaths.Add((programAsset, AssetDatabase.GetAssetPath(programAsset.sourceCsScript))); } UdonSharpProgramAsset[] programAssetsToCompile = modules.Select(e => e.programAsset).Where(e => e != null && e.sourceCsScript != null).ToArray(); try { beforeCompile?.Invoke(programAssetsToCompile); } catch (System.Exception e) { Debug.LogError($"Exception thrown by pre compile listener\n{e}"); } object syntaxTreeLock = new object(); List <(UdonSharpProgramAsset, Microsoft.CodeAnalysis.SyntaxTree)> programsAndSyntaxTrees = new List <(UdonSharpProgramAsset, Microsoft.CodeAnalysis.SyntaxTree)>(); Dictionary <UdonSharpProgramAsset, (string, Microsoft.CodeAnalysis.SyntaxTree)> syntaxTreeSourceLookup = new Dictionary <UdonSharpProgramAsset, (string, Microsoft.CodeAnalysis.SyntaxTree)>(); string[] defines = UdonSharpUtils.GetProjectDefines(isEditorBuild); Parallel.ForEach(programAssetsAndPaths, (currentProgram) => { string programSource = UdonSharpUtils.ReadFileTextSync(currentProgram.Item2); Microsoft.CodeAnalysis.SyntaxTree programSyntaxTree = CSharpSyntaxTree.ParseText(programSource, CSharpParseOptions.Default.WithDocumentationMode(DocumentationMode.None).WithPreprocessorSymbols(defines)); lock (syntaxTreeLock) { programsAndSyntaxTrees.Add((currentProgram.Item1, programSyntaxTree)); syntaxTreeSourceLookup.Add(currentProgram.Item1, (programSource, programSyntaxTree)); } });
private List <ClassDefinition> BuildClassDefinitions() { string[] udonSharpDataAssets = AssetDatabase.FindAssets($"t:{typeof(UdonSharpProgramAsset).Name}"); List <UdonSharpProgramAsset> udonSharpPrograms = new List <UdonSharpProgramAsset>(); foreach (string dataGuid in udonSharpDataAssets) { udonSharpPrograms.Add(AssetDatabase.LoadAssetAtPath <UdonSharpProgramAsset>(AssetDatabase.GUIDToAssetPath(dataGuid))); } List <ClassDefinition> classDefinitions = new List <ClassDefinition>(); foreach (UdonSharpProgramAsset udonSharpProgram in udonSharpPrograms) { if (udonSharpProgram.sourceCsScript == null) { continue; } string sourcePath = AssetDatabase.GetAssetPath(udonSharpProgram.sourceCsScript); string programSource = UdonSharpUtils.ReadFileTextSync(sourcePath); ResolverContext resolver = new ResolverContext(); SymbolTable classSymbols = new SymbolTable(resolver, null); classSymbols.OpenSymbolTable(); LabelTable classLabels = new LabelTable(); Microsoft.CodeAnalysis.SyntaxTree tree = CSharpSyntaxTree.ParseText(programSource); ClassVisitor classVisitor = new ClassVisitor(resolver, classSymbols, classLabels); try { classVisitor.Visit(tree.GetRoot()); } catch (System.Exception e) { UdonSharpUtils.LogBuildError($"{e.GetType()}: {e.Message}", sourcePath.Replace("/", "\\"), 0, 0); return(null); } classSymbols.CloseSymbolTable(); classVisitor.classDefinition.classScript = udonSharpProgram.sourceCsScript; classDefinitions.Add(classVisitor.classDefinition); } return(classDefinitions); }
public Microsoft.CodeAnalysis.SyntaxTree Translate(VSGraphModel graphModel, CompilationOptions options) { Profiler.BeginSample("Translation"); Microsoft.CodeAnalysis.SyntaxTree syntaxTree = ToSyntaxTree(graphModel, options); Profiler.EndSample(); if (syntaxTree is CSharpSyntaxTree cSharpSyntaxTree && syntaxTree.TryGetRoot(out var treeRoot)) { var treeOptions = cSharpSyntaxTree.Options.WithLanguageVersion(LanguageVersion); return(syntaxTree.WithRootAndOptions(treeRoot, treeOptions)); } return(syntaxTree); }
static SemanticModel GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree) { Profiler.BeginSample("CreateCompilation"); CSharpCompilation compilation = CSharpCompilation.Create("VSScriptCompilation", options: CompilationOptions, syntaxTrees: new[] { syntaxTree }, references: s_CachedAllReferences); Profiler.EndSample(); Profiler.BeginSample("GetSemModel"); SemanticModel semanticModel = compilation.GetSemanticModel(syntaxTree); Profiler.EndSample(); return(semanticModel); }
public virtual Microsoft.CodeAnalysis.SyntaxTree OnTranslate(VSGraphModel graphModel, AssemblyType assemblyType, CompilationOptions compilationOptions, ref CompilationResult compilationResult) { const string windowsLineEndings = "\r\n"; const string unixLineEndings = "\n"; Microsoft.CodeAnalysis.SyntaxTree syntaxTree = Translate(graphModel, compilationOptions); // we will measure plugins time later string preferredLineEndings; LineEndingsMode lineEndingsForNewScripts = EditorSettings.lineEndingsForNewScripts; switch (lineEndingsForNewScripts) { case LineEndingsMode.OSNative: preferredLineEndings = Application.platform == RuntimePlatform.WindowsEditor ? windowsLineEndings : unixLineEndings; break; case LineEndingsMode.Unix: preferredLineEndings = unixLineEndings; break; case LineEndingsMode.Windows: preferredLineEndings = windowsLineEndings; break; default: preferredLineEndings = unixLineEndings; break; } var adHocWorkspace = new AdhocWorkspace(); var options = adHocWorkspace.Options .WithChangedOption(CSharpFormattingOptions.NewLineForMembersInObjectInit, true) .WithChangedOption(CSharpFormattingOptions.WrappingPreserveSingleLine, false) .WithChangedOption(CSharpFormattingOptions.WrappingKeepStatementsOnSingleLine, false) .WithChangedOption(CSharpFormattingOptions.NewLinesForBracesInObjectCollectionArrayInitializers, true) .WithChangedOption(FormattingOptions.NewLine, LanguageNames.CSharp, preferredLineEndings); compilationResult.sourceCode[(int)SourceCodePhases.Initial] = syntaxTree.GetText().ToString(); var formattedTree = Formatter.Format(syntaxTree.GetCompilationUnitRoot(), adHocWorkspace, options); formattedTree = new VisualScriptingCSharpFormatter().Visit(formattedTree); string codeText = formattedTree.GetText().ToString(); compilationResult.sourceCode[(int)SourceCodePhases.Final] = codeText; return(syntaxTree); }
protected override void Initialize() { base.Initialize(); parseTree = VisualBasicSyntaxTree.ParseText(Editor.Text); var sourceText = SourceText.From(Editor.Text); var projectId = ProjectId.CreateNewId(); documentId = DocumentId.CreateNewId(projectId); var projectInfo = ProjectInfo.Create( projectId, VersionStamp.Create(), "TestProject", "TestProject", LanguageNames.VisualBasic, null, null, new VisualBasicCompilationOptions( OutputKind.DynamicallyLinkedLibrary ), new VisualBasicParseOptions(), new [] { DocumentInfo.Create( documentId, Editor.FileName, null, SourceCodeKind.Regular, TextLoader.From(TextAndVersion.Create(sourceText, VersionStamp.Create())), filePath: Editor.FileName ) }, null, DefaultMetadataReferences ); var sInfo = SolutionInfo.Create( SolutionId.CreateNewId(), VersionStamp.Create(), null, new [] { projectInfo } ); workspace.OpenSolutionInfo(sInfo); Editor.SyntaxHighlighting = new ClassificationSyntaxHighlighting(workspace, documentId); workspace.InformDocumentOpen(documentId, Editor); }
static void ApplyPluginsToAst(ref Microsoft.CodeAnalysis.SyntaxTree syntaxTree, CompilationOptions options, Stencil stencil, ref CompilationResult result) { Profiler.BeginSample("Code Analysis"); // run all the syntactic code analyzers CompilationStatus status = CompilationStatus.Succeeded; result.pluginSourceCode = new Dictionary <Type, string>(); foreach (IRoslynPluginHandler handler in stencil.GetCompilationPluginHandlers(options).OfType <IRoslynPluginHandler>()) { handler.Apply(ref syntaxTree, options); result.pluginSourceCode[handler.GetType()] = syntaxTree.GetText().ToString(); } result.status = status; Profiler.EndSample(); }
private Compilation CompileCSharp(Microsoft.CodeAnalysis.SyntaxTree tree, OptimizationLevel level) { var references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(Object).Assembly.Location), MetadataReference.CreateFromFile(typeof(Console).Assembly.Location), }; var all = references.Concat(GetReferences()); var com = CSharpCompilation.Create( "Hello", syntaxTrees: new[] { tree }, references: all, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) .WithOptimizationLevel(level) ); return(com); }
internal FileModel(Microsoft.CodeAnalysis.SyntaxTree tree, ParseOptions options) { Tree = tree; var structs = tree.GetCompilationUnitRoot().DescendantNodes(n => !(n is StructDeclarationSyntax)).OfType <StructDeclarationSyntax>(); var classes = tree.GetCompilationUnitRoot().DescendantNodes(n => !(n is ClassDeclarationSyntax)).OfType <ClassDeclarationSyntax>(); Structs = new List <StructModel>(); foreach (var s in structs) { var matchingProxy = classes.SingleOrDefault(c => c.Identifier.Text == StructModel.MakeProxyName(s.Identifier.Text)); var model = ParseStruct(s, matchingProxy); if (model != null) { Structs.Add(model); } } if (Structs.Count > 1 && options == ParseOptions.DisallowMultipleStructs) { throw new InvalidOperationException("File contains multiple component definitions"); } }
static CompilationResult CheckSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree, CompilationResult compilationResult) { SemanticModel semanticModel = GetSemanticModel(syntaxTree); // run all the semantic code analyzers var diagnostics = new List <CompilerError>(); Profiler.BeginSample("GetDiagnostics"); ImmutableArray <Diagnostic> rawDiagnostics = semanticModel.GetDiagnostics(); Profiler.EndSample(); Profiler.BeginSample("ProcessDiagnostics"); ProcessDiagnostics(rawDiagnostics, diagnostics); Profiler.EndSample(); if (diagnostics.Any()) { compilationResult.errors = diagnostics; } return(compilationResult); }
public CompileTaskResult Compile(List <ClassDefinition> classDefinitions) { programAsset.compileErrors.Clear(); Microsoft.CodeAnalysis.SyntaxTree tree = CSharpSyntaxTree.ParseText(sourceCode); CompileTaskResult result = new CompileTaskResult(); result.programAsset = programAsset; int errorCount = 0; foreach (Diagnostic diagnostic in tree.GetDiagnostics()) { if (diagnostic.Severity == DiagnosticSeverity.Error) { errorCount++; LinePosition linePosition = diagnostic.Location.GetLineSpan().StartLinePosition; CompileError error = new CompileError(); error.script = programAsset.sourceCsScript; error.errorStr = $"error {diagnostic.Descriptor.Id}: {diagnostic.GetMessage()}"; error.lineIdx = linePosition.Line; error.charIdx = linePosition.Character; result.compileErrors.Add(error); } } if (errorCount > 0) { return(result); } moduleSymbols.OpenSymbolTable(); UdonSharpFieldVisitor fieldVisitor = new UdonSharpFieldVisitor(fieldsWithInitializers); fieldVisitor.Visit(tree.GetRoot()); MethodVisitor methodVisitor = new MethodVisitor(resolver, moduleSymbols, moduleLabels); methodVisitor.Visit(tree.GetRoot()); ClassDebugInfo debugInfo = null; if (settings == null || settings.buildDebugInfo) { debugInfo = new ClassDebugInfo(sourceCode, settings == null || settings.includeInlineCode); } ASTVisitor visitor = new ASTVisitor(resolver, moduleSymbols, moduleLabels, methodVisitor.definedMethods, classDefinitions, debugInfo); try { visitor.Visit(tree.GetRoot()); visitor.VerifyIntegrity(); } catch (System.Exception e) { SyntaxNode currentNode = visitor.visitorContext.currentNode; string logMessage = ""; if (currentNode != null) { FileLinePositionSpan lineSpan = currentNode.GetLocation().GetLineSpan(); CompileError error = new CompileError(); error.script = programAsset.sourceCsScript; error.errorStr = $"{e.GetType()}: {e.Message}"; error.lineIdx = lineSpan.StartLinePosition.Line; error.charIdx = lineSpan.StartLinePosition.Character; result.compileErrors.Add(error); } else { logMessage = e.ToString(); Debug.LogException(e); } #if UDONSHARP_DEBUG Debug.LogException(e); Debug.LogError(e.StackTrace); #endif programAsset.compileErrors.Add(logMessage); errorCount++; } if (errorCount > 0) { return(result); } moduleSymbols.CloseSymbolTable(); if (errorCount == 0) { compiledClassDefinition = classDefinitions.Find(e => e.userClassType == visitor.visitorContext.behaviourUserType); string dataBlock = BuildHeapDataBlock(); string codeBlock = visitor.GetCompiledUasm(); result.compiledAssembly = dataBlock + codeBlock; result.symbolCount = (uint)(moduleSymbols.GetAllUniqueChildSymbols().Count + visitor.GetExternStrCount()); programAsset.behaviourIDHeapVarName = visitor.GetIDHeapVarName(); programAsset.fieldDefinitions = visitor.visitorContext.localFieldDefinitions; if (debugInfo != null) { debugInfo.FinalizeDebugInfo(); } programAsset.debugInfo = debugInfo; } return(result); }
public CompilationTracker FreezePartialStateWithTree(Solution solution, DocumentState docState, SyntaxTree tree, CancellationToken cancellationToken) { ProjectState inProgressProject; Compilation inProgressCompilation; GetPartialCompilationState(solution, docState.Id, out inProgressProject, out inProgressCompilation, cancellationToken); if (!inProgressCompilation.SyntaxTrees.Contains(tree)) { var existingTree = inProgressCompilation.SyntaxTrees.FirstOrDefault(t => t.FilePath == tree.FilePath); if (existingTree != null) { inProgressCompilation = inProgressCompilation.ReplaceSyntaxTree(existingTree, tree); inProgressProject = inProgressProject.UpdateDocument(docState, textChanged: false, recalculateDependentVersions: false); } else { inProgressCompilation = inProgressCompilation.AddSyntaxTrees(tree); Debug.Assert(!inProgressProject.DocumentIds.Contains(docState.Id)); inProgressProject = inProgressProject.AddDocument(docState); } } // The user is asking for an in progress snap. We don't want to create it and then a // have the compilation immediately disappear. So we force it to stay around with a ConstantValueSource return(new CompilationTracker(inProgressProject, new FinalState(new ConstantValueSource <Compilation>(inProgressCompilation)))); }
private static TreeAndVersion MakeNewTreeAndVersion(SyntaxTree oldTree, SourceText oldText, VersionStamp oldVersion, SyntaxTree newTree, SourceText newText, VersionStamp newVersion) { var topLevelChanged = TopLevelChanged(oldTree, oldText, newTree, newText); var version = topLevelChanged ? newVersion : oldVersion; return(TreeAndVersion.Create(newTree, version)); }
/// <summary> /// Gets the documentId in this solution with the specified syntax tree. /// </summary> public DocumentId GetDocumentId(SyntaxTree syntaxTree) => GetDocumentId(syntaxTree, projectId: null);
/// <summary> /// Gets the document in this solution with the specified syntax tree. /// </summary> public Document GetDocument(SyntaxTree syntaxTree) { return(this.GetDocument(syntaxTree, projectId: null)); }
/// <summary> /// 生成Dll /// </summary> /// <param name="csprojName"></param> /// <param name="path"></param> /// <param name="buildType"></param> /// <param name="isUseDefine"></param> /// <returns></returns> public static bool BuildDll(string csprojName, string path, BuildType buildType, bool isUseDefine) { bool isDebug = buildType == BuildType.Debug ? true : false; //项目相关所有宏 List <string> defineList = new List <string>(); //项目相关所有dll List <string> dllFilePathList = new List <string>(); //项目本身cs文件 List <string> csFilePathList = ReadCSPROJ(csprojName, ref defineList, ref dllFilePathList); List <Microsoft.CodeAnalysis.SyntaxTree> csFileList = new List <Microsoft.CodeAnalysis.SyntaxTree>(); List <MetadataReference> dllFileList = new List <MetadataReference>(); CSharpParseOptions parseOptions; //宏是否开启 if (isUseDefine) { parseOptions = new CSharpParseOptions(LanguageVersion.Latest, preprocessorSymbols: defineList); } else { parseOptions = new CSharpParseOptions(LanguageVersion.Latest); } //增加dll文件 foreach (string item in dllFilePathList) { PortableExecutableReference dll = MetadataReference.CreateFromFile(item); if (dll == null) { continue; } dllFileList.Add(dll); } //增加cs文件 foreach (string item in csFilePathList) { if (File.Exists(item)) { Microsoft.CodeAnalysis.SyntaxTree cs = CSharpSyntaxTree.ParseText(FileUtil.GetAsset(item).GetString(), parseOptions, item, Encoding.UTF8); if (cs == null) { continue; } csFileList.Add(cs); } } //设置编译参数 CSharpCompilationOptions compilationOptions; if (isDebug) { compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Debug, warningLevel: 4, allowUnsafe: true); } else { compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release, warningLevel: 4, allowUnsafe: true); } string assemblyName = Path.GetFileNameWithoutExtension(path); //开始编译 CSharpCompilation compilation = CSharpCompilation.Create(assemblyName, csFileList, dllFileList, compilationOptions); EmitResult result; if (isDebug) { string pdbPath = path.Replace(".dll", ".pdb"); EmitOptions emitOptions = new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb, pdbFilePath: pdbPath); using (MemoryStream dllStream = new MemoryStream()) { using (MemoryStream pdbStream = new MemoryStream()) { result = compilation.Emit(dllStream, pdbStream, options: emitOptions); FileUtil.SaveAsset(path, dllStream.GetBuffer()); FileUtil.SaveAsset(pdbPath, pdbStream.GetBuffer()); } } } else { result = compilation.Emit(path); } if (result.Success) { LogUtil.Log("编译成功"); } else { List <Diagnostic> failureList = (from diagnostic in result.Diagnostics where diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error select diagnostic).ToList(); foreach (Diagnostic item in failureList) { LogUtil.Log(item.ToString()); } } return(result.Success); }
public abstract IList <TextChange> GetChanges(SyntaxTree oldTree);
/// <summary> /// Get the document in this project with the specified syntax tree. /// </summary> public Document GetDocument(SyntaxTree syntaxTree) { return(_solution.GetDocument(syntaxTree, this.Id)); }
public void Compile() { Profiler.BeginSample("UdonSharp Compile"); System.Diagnostics.Stopwatch compileTimer = new System.Diagnostics.Stopwatch(); compileTimer.Start(); int totalErrorCount = 0; try { EditorUtility.DisplayProgressBar("UdonSharp Compile", "Initializing...", 0f); UdonSharpProgramAsset[] allPrograms = UdonSharpProgramAsset.GetAllUdonSharpPrograms(); List <(UdonSharpProgramAsset, string)> programAssetsAndPaths = new List <(UdonSharpProgramAsset, string)>(); foreach (UdonSharpProgramAsset programAsset in allPrograms) { if (programAsset == null) { continue; } if (programAsset.sourceCsScript == null) { Debug.LogWarning($"[<color=#FF00FF>UdonSharp</color>] Program asset '{AssetDatabase.GetAssetPath(programAsset)}' is missing a source C# script"); continue; } programAssetsAndPaths.Add((programAsset, AssetDatabase.GetAssetPath(programAsset.sourceCsScript))); programAsset.compileErrors.Clear(); // Clear compile errors to keep them from stacking if not resolved } CheckProgramAssetCollisions(allPrograms); UdonSharpProgramAsset[] programAssetsToCompile = modules.Select(e => e.programAsset).Where(e => e != null && e.sourceCsScript != null).ToArray(); EditorUtility.DisplayProgressBar("UdonSharp Compile", "Executing pre-build events...", 0f); try { beforeCompile?.Invoke(programAssetsToCompile); } catch (System.Exception e) { Debug.LogError($"Exception thrown by pre compile listener\n{e}"); } EditorUtility.DisplayProgressBar("UdonSharp Compile", "Parsing Syntax Trees...", 0f); object syntaxTreeLock = new object(); List <(UdonSharpProgramAsset, Microsoft.CodeAnalysis.SyntaxTree)> programsAndSyntaxTrees = new List <(UdonSharpProgramAsset, Microsoft.CodeAnalysis.SyntaxTree)>(); Dictionary <UdonSharpProgramAsset, (string, Microsoft.CodeAnalysis.SyntaxTree)> syntaxTreeSourceLookup = new Dictionary <UdonSharpProgramAsset, (string, Microsoft.CodeAnalysis.SyntaxTree)>(); string[] defines = UdonSharpUtils.GetProjectDefines(isEditorBuild); Parallel.ForEach(programAssetsAndPaths, (currentProgram) => { string programSource = UdonSharpUtils.ReadFileTextSync(currentProgram.Item2); #pragma warning disable CS1701 // Warning about System.Collections.Immutable versions potentially not matching Microsoft.CodeAnalysis.SyntaxTree programSyntaxTree = CSharpSyntaxTree.ParseText(programSource, CSharpParseOptions.Default.WithDocumentationMode(DocumentationMode.None).WithPreprocessorSymbols(defines)); #pragma warning restore CS1701 lock (syntaxTreeLock) { programsAndSyntaxTrees.Add((currentProgram.Item1, programSyntaxTree)); syntaxTreeSourceLookup.Add(currentProgram.Item1, (programSource, programSyntaxTree)); } });
public override AnalyzerConfigOptions GetOptions(SyntaxTree tree) { return(new WorkspaceAnalyzerConfigOptions(_projectState._lazyAnalyzerConfigSet.GetValue(CancellationToken.None).GetOptionsForSourcePath(tree.FilePath))); }
public ICompilationTracker FreezePartialStateWithTree(SolutionState solution, DocumentState docState, SyntaxTree tree, CancellationToken cancellationToken) { // Because we override SourceGeneratedDocument.WithFrozenPartialSemantics directly, we shouldn't be able to get here. throw ExceptionUtilities.Unreachable; }
public abstract bool IsEquivalentTo(SyntaxTree tree, bool topLevel = false);
public abstract IList <TextSpan> GetChangedSpans(SyntaxTree syntaxTree);
public CompileTaskResult Compile(List <ClassDefinition> classDefinitions, Microsoft.CodeAnalysis.SyntaxTree syntaxTree, string sourceCode, bool isEditorBuild) { programAsset.compileErrors.Clear(); CompileTaskResult result = new CompileTaskResult(); result.programAsset = programAsset; moduleSymbols.OpenSymbolTable(); UdonSharpFieldVisitor fieldVisitor = new UdonSharpFieldVisitor(fieldsWithInitializers); fieldVisitor.Visit(syntaxTree.GetRoot()); MethodVisitor methodVisitor = new MethodVisitor(resolver, moduleSymbols, moduleLabels); int errorCount = 0; try { methodVisitor.Visit(syntaxTree.GetRoot()); } catch (System.Exception e) { LogException(result, e, methodVisitor.visitorContext.currentNode, out string logMessage); programAsset.compileErrors.Add(logMessage); errorCount++; } if (ErrorCount > 0) { return(result); } ClassDebugInfo debugInfo = null; if (settings == null || settings.buildDebugInfo) { debugInfo = new ClassDebugInfo(sourceCode, settings == null || settings.includeInlineCode); } ASTVisitor visitor = new ASTVisitor(resolver, moduleSymbols, moduleLabels, methodVisitor.definedMethods, classDefinitions, debugInfo); try { visitor.Visit(syntaxTree.GetRoot()); visitor.VerifyIntegrity(); } catch (System.Exception e) { LogException(result, e, visitor.visitorContext.currentNode, out string logMessage); programAsset.compileErrors.Add(logMessage); errorCount++; } if (errorCount > 0) { return(result); } moduleSymbols.CloseSymbolTable(); if (errorCount == 0) { compiledClassDefinition = classDefinitions.Find(e => e.userClassType == visitor.visitorContext.behaviourUserType); string dataBlock = BuildHeapDataBlock(); string codeBlock = visitor.GetCompiledUasm(); result.compiledAssembly = dataBlock + codeBlock; result.symbolCount = (uint)(moduleSymbols.GetAllUniqueChildSymbols().Count + visitor.GetExternStrCount()); programAsset.behaviourIDHeapVarName = visitor.GetIDHeapVarName(); programAsset.fieldDefinitions = visitor.visitorContext.localFieldDefinitions; #if UDON_BETA_SDK programAsset.behaviourSyncMode = visitor.visitorContext.behaviourSyncMode; #endif if (debugInfo != null) { debugInfo.FinalizeDebugInfo(); } UdonSharpEditorCache.Instance.SetDebugInfo(programAsset, isEditorBuild ? UdonSharpEditorCache.DebugInfoType.Editor : UdonSharpEditorCache.DebugInfoType.Client, debugInfo); //programAsset.debugInfo = debugInfo; } return(result); }