/// <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());
}
/// <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());
}
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 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());
}
protected override IEnumerable<string> ReportAllErrors(SyntaxTree userSolution)
{
var recursiveMethods = userSolution.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Where(IsRecursive).ToList();
if (requireRecursion && !recursiveMethods.Any())
yield return Report(userSolution.GetRoot(), "Решение должно быть рекурсивным");
if (!requireRecursion && recursiveMethods.Any())
yield return Report(userSolution.GetRoot(), "Решение должно быть нерекурсивным");
}
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 ExerciseBlock BuildBlockFrom(SyntaxTree tree)
{
ExerciseClassName = null;
Exercise.ExerciseInitialCode = GetUncomment(tree.GetRoot()) ?? ""; //for uncomment-comment without exercise method
SyntaxNode result = Visit(tree.GetRoot());
var exerciseInsertIndex = GetExerciseInsertIndex(result);
const string pragma = "\n#line 1\n";
Exercise.ExerciseCode = prelude + result.ToFullString().Insert(exerciseInsertIndex, pragma);
Exercise.IndexToInsertSolution = prelude.Length + exerciseInsertIndex + pragma.Length;
return Exercise;
}
public IEnumerable<Match> Run(SyntaxTree tree)
{
return tree.GetRoot()
.DescendantNodesAndTokensAndSelf()
.Select(CreateMatch)
.Where(n => n.IsMatch);
}
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 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;
}
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));
}
public static IEnumerable<PropertyDeclarationSyntax> GetProperties(SyntaxTree syntaxTree)
{
var result = syntaxTree.GetRoot().DescendantNodes()
.Where(node => node.IsKind(SyntaxKind.PropertyDeclaration))
.Cast<PropertyDeclarationSyntax>();
return result;
}
public IEnumerable<AttributeListSyntax> GetAttributeListsNodes(SyntaxTree syntaxTree)
{
if (syntaxTree == null) throw new ArgumentNullException(nameof(syntaxTree));
return syntaxTree.GetRoot()
.DescendantNodes()
.OfType<AttributeListSyntax>();
}
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)})");
}
}
/// <summary>
/// Rewrites the syntax tree with field access expressions.
/// </summary>
/// <param name="tree">SyntaxTree</param>
/// <returns>SyntaxTree</returns>
internal SyntaxTree Rewrite(SyntaxTree tree)
{
var expressions = tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().
ToList();
if (expressions.Count == 0)
{
return tree;
}
var root = tree.GetRoot().ReplaceNodes(
nodes: expressions,
computeReplacementNode: (node, rewritten) => this.RewriteExpression(rewritten));
return base.UpdateSyntaxTree(tree, root.ToString());
}
public static string GetNamespace(SyntaxTree syntaxTree)
{
return syntaxTree.GetRoot().DescendantNodes()
.Where(node => node.IsKind(SyntaxKind.NamespaceDeclaration))
.Cast<NamespaceDeclarationSyntax>()
.First()
.Name.ToString();
}
private static void ModifyTreeViaRewriter(SyntaxTree tree)
{
Console.Out.WriteLine(nameof(Program.ModifyTreeViaRewriter));
Console.Out.WriteLine(tree);
var newTree = new MethodRewriter().Visit(tree.GetRoot());
Console.Out.WriteLine(newTree);
}
public static bool IsExercise(SyntaxTree tree)
{
return
tree.GetRoot()
.DescendantNodes()
.OfType<MethodDeclarationSyntax>()
.Any(m => m.HasAttribute<ExpectedOutputAttribute>());
}
/// <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 IEnumerable<ClassDeclarationSyntax> GetAttributedClasses(SyntaxTree syntaxTree)
{
return syntaxTree.GetRoot().DescendantNodes()
.OfType<AttributeSyntax>()
.Where(attribute => attribute.Name.ToString().Equals("AutoGetHashCode"))
.Select(attribute => attribute.Parent.Parent)
.Cast<ClassDeclarationSyntax>();
}
/// <summary>
/// Rewrites the syntax tree with halt event types.
/// </summary>
/// <param name="tree">SyntaxTree</param>
/// <returns>SyntaxTree</returns>
internal SyntaxTree Rewrite(SyntaxTree tree)
{
var types = tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().
Where(val => val.Identifier.ValueText.Equals("halt")).
ToList();
if (types.Count == 0)
{
return tree;
}
var root = tree.GetRoot().ReplaceNodes(
nodes: types,
computeReplacementNode: (node, rewritten) => this.RewriteType(rewritten));
return base.UpdateSyntaxTree(tree, root.ToString());
}
public Metrics(SyntaxTree tree) : base(tree)
{
var root = tree.GetRoot();
if (root.Language != LanguageNames.VisualBasic)
{
throw new ArgumentException(InitalizationErrorTextPattern, nameof(tree));
}
}
private Boolean IsAutoGenerated(SyntaxTree tree)
=> tree.GetRoot()
.GetLeadingTrivia()
.Where(t =>
t.IsKind(SyntaxKind.SingleLineCommentTrivia)
&& t.ToString().IndexOf("<auto-generated>", StringComparison.OrdinalIgnoreCase) != -1
)
.Any();
/// <summary>
/// Rewrites the syntax tree with nondetermnistic choice expressions.
/// </summary>
/// <param name="tree">SyntaxTree</param>
/// <returns>SyntaxTree</returns>
internal SyntaxTree Rewrite(SyntaxTree tree)
{
var expressions = tree.GetRoot().DescendantNodes().OfType<PrefixUnaryExpressionSyntax>().
Where(val => val.Kind() == SyntaxKind.PointerIndirectionExpression).
Where(val => val.Parent is IfStatementSyntax).
ToList();
if (expressions.Count == 0)
{
return tree;
}
var root = tree.GetRoot().ReplaceNodes(
nodes: expressions,
computeReplacementNode: (node, rewritten) => this.RewriteExpression(rewritten));
return base.UpdateSyntaxTree(tree, root.ToString());
}
public string FindError(SyntaxTree userSolution)
{
var cu = userSolution.GetRoot() as CompilationUnitSyntax;
if (cu == null) return ShouldBeMethod;
if (cu.Members.Count > 1) return ShouldBeSingleMethod;
var method = cu.Members[0] as MethodDeclarationSyntax;
if (method == null) return ShouldBeMethod;
return FindError(method);
}
/// <summary>
/// Rewrites the syntax tree with assert statements.
/// </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("assert")).
ToList();
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());
}
private static bool HasGeneratedRegion(SyntaxTree tree)
{
return tree
.GetRoot()
.DescendantTrivia()
.Any(
t =>
t.IsKind(SyntaxKind.RegionDirectiveTrivia) &&
CultureInfo.InvariantCulture.CompareInfo.IndexOf(t.ToString(), "generated", CompareOptions.IgnoreCase) >= 0);
}
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");
}
}
private static Slide ParseSyntaxTree(SyntaxTree tree, SlideInfo slideInfo, string prelude,
IFileSystem getInclude)
{
var blocksBuilder = new SlideBuilder(getInclude);
blocksBuilder.Visit(tree.GetRoot());
if (!ExerciseBuilder.IsExercise(tree))
return new Slide(blocksBuilder.Blocks, slideInfo, blocksBuilder.Title, blocksBuilder.Id);
var exerciseBlock = new ExerciseBuilder(SlideBuilder.LangId, prelude).BuildBlockFrom(tree);
blocksBuilder.Blocks.Add(exerciseBlock);
return new ExerciseSlide(blocksBuilder.Blocks, slideInfo, blocksBuilder.Title, blocksBuilder.Id);
}
private static void ModifyTreeViaTree(SyntaxTree tree)
{
Console.Out.WriteLine(nameof(Program.ModifyTreeViaTree));
Console.Out.WriteLine(tree);
var methods = tree.GetRoot().DescendantNodes(_ => true)
.OfType<MethodDeclarationSyntax>();
var newTree = tree.GetRoot().ReplaceNodes(methods, (method, methodWithReplacements) =>
{
var visibilityTokens = method.DescendantTokens(_ => true)
.Where(_ => _.IsKind(SyntaxKind.PublicKeyword) ||
_.IsKind(SyntaxKind.PrivateKeyword) ||
_.IsKind(SyntaxKind.ProtectedKeyword) ||
_.IsKind(SyntaxKind.InternalKeyword)).ToImmutableList();
if (!visibilityTokens.Any(_ => _.IsKind(SyntaxKind.PublicKeyword)))
{
var tokenPosition = 0;
var newMethod = method.ReplaceTokens(visibilityTokens,
(_, __) =>
{
tokenPosition++;
return tokenPosition == 1 ?
SyntaxFactory.Token(
_.LeadingTrivia,
SyntaxKind.PublicKeyword,
_.TrailingTrivia) :
new SyntaxToken();
});
return newMethod;
}
else
{
return method;
}
});
Console.Out.WriteLine(newTree);
}
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);
}
/// <summary>
/// Normalizes the <paramref name="syntaxTree" /> of the <see cref="Compilation" />.
/// </summary>
/// <param name="syntaxTree">The syntax tree that should be normalized.</param>
protected virtual SyntaxTree Normalize(SyntaxTree syntaxTree)
{
SemanticModel = Compilation.GetSemanticModel(syntaxTree);
_rootNode = syntaxTree.GetRoot();
var normalizedRoot = Visit(_rootNode);
if (_rootNode == normalizedRoot)
return syntaxTree;
return syntaxTree.WithRoot(normalizedRoot);
}
public List <string> GetMethodParams(string scriptCode, int position)
{
//position = position - 2;
List <string> overloads = new List <string>();
var meta = AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES");
string[] assemblies = 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();
try
{
if (_ref == null)
{
_ref = _ref = new MetadataReference[0];
var assembliest = AppDomain.CurrentDomain.GetAssemblies()
.Where(a => !a.IsDynamic && File.Exists(a.Location));
MetadataReference[] _refs2 = assembliest
.Select(asm => MetadataReference.CreateFromFile(asm.Location))
.ToArray();
try
{
foreach (var item in DependencyContext.Default.CompileLibraries)
{
try
{
var arr = item.ResolveReferencePaths().Select(asm => MetadataReference.CreateFromFile(asm))?
.ToArray();
_ref = _ref.Concatenate(arr);
}
catch (Exception)
{
}
}
}
catch (Exception)
{
}
_ref = _ref.Concatenate(_refs2);
}
var Mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var compilation = CSharpCompilation.Create("MyCompilation",
syntaxTrees: new[] { syntaxTree }, references: _ref);
var model = compilation.GetSemanticModel(syntaxTree);
var theToken = syntaxTree.GetRoot().FindToken(position);
var theNode = theToken.Parent;
while (!theNode.IsKind(Microsoft.CodeAnalysis.CSharp.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;
//overloads = containingType?.GetMembers(symbol.Name);
if (symbolInfo.CandidateSymbols != null)
{
if (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);
//var smpl = parameters.ToMinimalDisplayString();
overloads.Add(mp);
}
}
}
}
}
return(overloads);
}
catch (Exception)
{
return(null);
}
}
public AnalyzerWithInvalidDiagnosticLocation(SyntaxTree treeInAnotherCompilation, ActionKind actionKind)
{
_invalidLocation = treeInAnotherCompilation.GetRoot().GetLocation();
_actionKind = actionKind;
}
private void ReportTreeDiagnostics(SyntaxTree tree, Action <Diagnostic> addDiagnostic)
{
ReportDiagnosticsCore(addDiagnostic, tree.GetRoot().GetLastToken().GetLocation(), tree.FilePath);
}
private static SourceText BuildRecoverableTreeText(SyntaxTree tree, Encoding encoding, CancellationToken cancellationToken)
{
// build text from root, so recoverable tree won't cycle.
return(tree.GetRoot(cancellationToken).GetText(encoding));
}
internal static void VerifySource(this SyntaxTree tree, IEnumerable <TextChangeRange> changes = null)
{
var root = tree.GetRoot();
var text = tree.GetText();
var fullSpan = new TextSpan(0, text.Length);
SyntaxNode node = null;
// If only a subset of the document has changed,
// just check that subset to reduce verification cost.
if (changes != null)
{
var change = TextChangeRange.Collapse(changes).Span;
if (change != fullSpan)
{
// Find the lowest node in the tree that contains the changed region.
node = root.DescendantNodes(n => n.FullSpan.Contains(change)).LastOrDefault();
}
}
if (node == null)
{
node = root;
}
var span = node.FullSpan;
var textSpanOpt = span.Intersection(fullSpan);
int index;
char found = default;
char expected = default;
if (textSpanOpt == null)
{
index = 0;
}
else
{
var fromText = text.ToString(textSpanOpt.Value);
var fromNode = node.ToFullString();
index = FindFirstDifference(fromText, fromNode);
if (index >= 0)
{
found = fromNode[index];
expected = fromText[index];
}
}
if (index >= 0)
{
index += span.Start;
string message;
if (index < text.Length)
{
var position = text.Lines.GetLinePosition(index);
var line = text.Lines[position.Line];
var allText = text.ToString(); // Entire document as string to allow inspecting the text in the debugger.
message = $"Unexpected difference at offset {index}: Line {position.Line + 1}, Column {position.Character + 1} \"{line.ToString()}\" (Found: [{found}] Expected: [{expected}])";
}
else
{
message = "Unexpected difference past end of the file";
}
Debug.Assert(false, message);
}
}
public static SourceGeneratedDocumentState Create(
string hintName,
SourceText generatedSourceText,
SyntaxTree generatedSyntaxTree,
DocumentId documentId,
ISourceGenerator sourceGenerator,
HostLanguageServices languageServices,
SolutionServices solutionServices,
CancellationToken cancellationToken
)
{
var options = generatedSyntaxTree.Options;
var filePath = generatedSyntaxTree.FilePath;
var textAndVersion = TextAndVersion.Create(generatedSourceText, VersionStamp.Create());
ValueSource <TextAndVersion> textSource = new ConstantValueSource <TextAndVersion>(
textAndVersion
);
var root = generatedSyntaxTree.GetRoot(cancellationToken);
Contract.ThrowIfNull(
languageServices.SyntaxTreeFactory,
"We should not have a generated syntax tree for a language that doesn't support trees."
);
if (languageServices.SyntaxTreeFactory.CanCreateRecoverableTree(root))
{
// We will only create recoverable text if we can create a recoverable tree; if we created a
// recoverable text but not a new tree, it would mean tree.GetText() could still potentially return
// the non-recoverable text, but asking the document directly for it's text would give a recoverable
// text with a different object identity.
textSource = CreateRecoverableText(textAndVersion, solutionServices);
generatedSyntaxTree = languageServices.SyntaxTreeFactory.CreateRecoverableTree(
documentId.ProjectId,
filePath: generatedSyntaxTree.FilePath,
options,
textSource,
generatedSourceText.Encoding,
root
);
}
var treeAndVersion = TreeAndVersion.Create(generatedSyntaxTree, textAndVersion.Version);
return(new SourceGeneratedDocumentState(
languageServices,
solutionServices,
documentServiceProvider: null,
new DocumentInfo.DocumentAttributes(
documentId,
name: hintName,
folders: SpecializedCollections.EmptyReadOnlyList <string>(),
options.Kind,
filePath: filePath,
isGenerated: true,
designTimeOnly: false
),
options,
sourceText: null, // don't strongly hold the text
textSource,
treeAndVersion,
sourceGenerator,
hintName
));
}
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 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);
}