public static List <INamedTypeSymbol> GetClassDeclarations(CSharpSyntaxTree tree, SemanticModel model) { return(tree.GetCompilationUnitRoot().DescendantNodes().OfType <ClassDeclarationSyntax>() .Select(c => model.GetDeclaredSymbol(c)) .Where(c => c.DeclaredAccessibility == Accessibility.Public) .ToList()); }
private static CSharpCompilation EditCompilation(CSharpCompilation compilation, CancellationToken cancellationToken) { int syntaxTreesLength = compilation.SyntaxTrees.Length; for (int i = 0; i < syntaxTreesLength; i++) { CSharpSyntaxTree tree = compilation.SyntaxTrees[i] as CSharpSyntaxTree; if (tree == null) { continue; } MacroExpander expander = new MacroExpander(tree, compilation, cancellationToken); SyntaxNode root = tree.GetCompilationUnitRoot(cancellationToken); SyntaxNode newRoot = expander.Visit(root); if (root != newRoot) { compilation = compilation.ReplaceSyntaxTree(tree, tree.WithRootAndOptions(newRoot, tree.Options)); } } return(compilation); }
private CompilationUnitSyntax FixCase(CompilationUnitSyntax root) { //var tokens = from token in root.DescendentTokens() // where token.Value == "While" // select token; //foreach (SyntaxToken token in tokens) //{ // SyntaxToken newtoken = Syntax.ex ("", ""); // //token.ValueText = "while"; //} //ParseOptions parseOptions = new ParseOptions(CompatibilityMode.None, LanguageVersion.CSharp1, null, false, SourceCodeKind.Script); CSharpParseOptions cSharpParseOptions = new CSharpParseOptions(LanguageVersion.CSharp1, DocumentationMode.Parse, SourceCodeKind.Script); CSharpSyntaxRewriter cSharpSyntaxRewriter = new CaseFixRewriter(); SyntaxNode newRoot = cSharpSyntaxRewriter.Visit(root); // new CaseFixRewriter().Visit(root); //tree = SyntaxTree.ParseCompilationUnit(newRoot.GetFullText(), options: parseOptions); tree = CSharpSyntaxTree.ParseText(newRoot.GetText(), options: cSharpParseOptions) as CSharpSyntaxTree; //tree = SyntaxTree.Create(tree.FileName, (CompilationUnitSyntax)newRoot, options: parseOptions); //Console.WriteLine(tree.Root.GetFullText()); //Console.ReadLine(); //string strings = tree.Root.GetFullText(); //return (CompilationUnitSyntax)tree.Root; return(tree.GetCompilationUnitRoot()); }
public void OpenFile(string filePath) { string str = File.ReadAllText(filePath, Encoding.UTF8); TreeNode root = this.treeView1.Nodes.Add(Path.GetFileName(filePath)); CSharpSyntaxTree syntax = (CSharpSyntaxTree)CSharpSyntaxTree.ParseText(str); CSharpCodeWalker walker = new CSharpCodeWalker(root); walker.VisitCompilationUnit(syntax.GetCompilationUnitRoot()); }
private void BuildSource() { this.SourceCode = ""; //create tree CSharpParseOptions cSharpParseOptions = new CSharpParseOptions(LanguageVersion.CSharp1, DocumentationMode.Parse, SourceCodeKind.Script); tree = CSharpSyntaxTree.ParseText("", options: cSharpParseOptions, encoding: ansii) as CSharpSyntaxTree; BlockHelper.Root = tree.GetCompilationUnitRoot(); //(CompilationUnitSyntax)tree.GetRoot(); variableSet.BuildVariables(this.ParsedContent); ParseOpCodes(); //move first block contents to root BlockSyntax block = BlockHelper.GetFirstBlock(); block = variableSet.AddVariablesToBlock(block); List <MemberDeclarationSyntax> globalStatements = new List <MemberDeclarationSyntax>(); foreach (var statement in block.Statements) { GlobalStatementSyntax globalStatement = SyntaxFactory.GlobalStatement(statement); globalStatements.Add(globalStatement); } tree = CSharpSyntaxTree.ParseText("", options: cSharpParseOptions, encoding: ansii) as CSharpSyntaxTree; BlockHelper.Root = tree.GetCompilationUnitRoot(); //(CompilationUnitSyntax)tree.GetRoot(); BlockHelper.Root = BlockHelper.Root.AddMembers(globalStatements.ToArray()); var workspace = new AdhocWorkspace(); //OptionSet options = workspace.Options; //options = options.WithChangedOption(CSharpFormattingOptions. SyntaxNode formatted = Formatter.Format(BlockHelper.Root, workspace); //, options); this.SourceCode = formatted.GetText().ToString(); //this.SourceCode = BlockHelper.Root.GetText().ToString(); //.GetFullText().ToString(); }
public CompilationUnitSyntax Parse() { //Console.WriteLine("Parsing..."); string source_text = File.ReadAllText(Path.Combine(this.SourceDirectory, this.ScriptFilename), System.Text.Encoding.GetEncoding(1252)); //Console.WriteLine("---Input---\n"); //Console.WriteLine(source_text); //ParseOptions parseOptions = new ParseOptions(CompatibilityMode.None, LanguageVersion.CSharp1, null, false, SourceCodeKind.Script); CSharpParseOptions cSharpParseOptions = new CSharpParseOptions(LanguageVersion.CSharp1, DocumentationMode.Parse, SourceCodeKind.Script); //var tree = SyntaxTree.ParseCompilationUnit(source_text, parseOptions); //parse and get root //SyntaxTree tree = SyntaxTree.ParseCompilationUnit(source_text); //tree = SyntaxTree.ParseCompilationUnit(source_text, options: parseOptions); tree = CSharpSyntaxTree.ParseText(source_text, options: cSharpParseOptions) as CSharpSyntaxTree; //return (CompilationUnitSyntax)tree.Root; return(tree.GetCompilationUnitRoot()); }
static void Main(string[] args) { Console.WriteLine("Building..."); semi = SyntaxFactory.Token(SyntaxFactory.TriviaList(), SyntaxKind.SemicolonToken, SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine("\n"))); CSharpParseOptions cSharpParseOptions = new CSharpParseOptions(LanguageVersion.CSharp1, DocumentationMode.Parse, SourceCodeKind.Script); tree = CSharpSyntaxTree.ParseText("", options: cSharpParseOptions) as CSharpSyntaxTree; root = tree.GetCompilationUnitRoot(); //(CompilationUnitSyntax)tree.GetRoot(); //create the block and add it var syntaxAnnotation = new SyntaxAnnotation("Block", "1"); BlockSyntax block = SyntaxFactory.Block().WithAdditionalAnnotations(syntaxAnnotation); currentBlock = syntaxAnnotation; //add block to root GlobalStatementSyntax globalStatement = SyntaxFactory.GlobalStatement(block); root = root.AddMembers(globalStatement); //root = root.WithMembers(root.Members.Add(globalStatement)); //add to first block ExpressionSyntax expressionSyntax = SyntaxFactory.IdentifierName("Print"); ArgumentListSyntax argumentList = SyntaxFactory.ParseArgumentList("(" + "arg1, \"literal1\"" + ")"); //Print("// Sebastian Marsh (001790): That’s not going to happen, Robert."); // InvocationExpressionSyntax invocationExpression = SyntaxFactory.InvocationExpression(expressionSyntax, argumentList); ExpressionStatementSyntax expressionStatement = SyntaxFactory.ExpressionStatement(invocationExpression, semi); AddToCurrentBlock(expressionStatement); //add a block to the block syntaxAnnotation = new SyntaxAnnotation("Block", "2"); BlockSyntax newBlock = SyntaxFactory.Block().WithAdditionalAnnotations(syntaxAnnotation); AddToCurrentBlock(newBlock); currentBlock = syntaxAnnotation; var variableIdentifier = SyntaxFactory.IdentifierName("vVar"); //var variableExpression = GetVariableExpression(assignValue); int value = int.Parse("1"); var variableExpression = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(value)); var binaryExpression = SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, variableIdentifier, variableExpression); //AssignmentExpressionSyntax assignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, variableIdentifier, variableExpression); AssignmentExpressionSyntax assignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, variableIdentifier, binaryExpression); expressionStatement = SyntaxFactory.ExpressionStatement(assignment, semi); //add to the current block AddToCurrentBlock(expressionStatement); //move back a block GetPreviousBlock(); var variable = GetVariable(); SyntaxToken insertAfter = block.GetFirstToken(); SyntaxNode insertAfterNode = null; BlockSyntax theBlock = GetCurrentBlock(); foreach (var token in theBlock.DescendantTokens().Where(n => n.ValueText == "literal1")) { insertAfter = FindNextSemi(token); insertAfterNode = insertAfter.Parent; } VariableDeclaratorSyntax declarator = SyntaxFactory.VariableDeclarator(identifier: SyntaxFactory.Identifier("var12")); VariableDeclarationSyntax variableDeclaration = SyntaxFactory.VariableDeclaration(type: SyntaxFactory.ParseTypeName("String "), variables: SyntaxFactory.SeparatedList <VariableDeclaratorSyntax>().Add(declarator)); SyntaxTokenList modifiers = new SyntaxTokenList(); LocalDeclarationStatementSyntax localDeclaration = SyntaxFactory.LocalDeclarationStatement(modifiers, variableDeclaration, semi); BlockSyntax addBlock = SyntaxFactory.Block(localDeclaration); root = root.InsertNodesAfter(insertAfterNode, addBlock.ChildNodes()); //show source //block = root.DescendantNodes().OfType<BlockSyntax>().Where(n => n.HasAnnotation(currentBlock)).Single(); //Console.WriteLine("block source:"); //Console.WriteLine(block.GetText()); Console.WriteLine("root source:"); Console.WriteLine(root.GetText()); Console.WriteLine("Complete."); Console.ReadLine(); }
/// <inheritdoc /> protected override void Initialize(CSharpCompilation oldCompilation, CancellationToken _) { OptimizationLevel compilationConfiguration = oldCompilation.Options.OptimizationLevel; DebugCometaryAttribute attribute = Attribute; if (compilationConfiguration == OptimizationLevel.Debug && !attribute.RunInDebug) { return; } if (compilationConfiguration == OptimizationLevel.Release && !attribute.RunInRelease) { return; } string typeName = attribute.MainClassName ?? DebugCometaryAttribute.DefaultMainClassName; if (Assembly.GetEntryAssembly().GetType(typeName) != null) { return; } CSharpCompilation EditCompilation(CSharpCompilation compilation, CancellationToken cancellationToken) { CSharpCompilationOptions options = compilation.Options; CSharpCompilationOptions newOptions = options .WithOutputKind(OutputKind.ConsoleApplication) .WithMainTypeName(typeName); // - Make the compilation an application, allowing its execution. // - Redirect the entry point to the automatically generated class. compilation = compilation.WithOptions(newOptions); // Create the entry point: string errorFile = Path.GetTempFileName(); CSharpSyntaxTree generatedSyntaxTree = (CSharpSyntaxTree)CSharpSyntaxTree.ParseText(GetSourceText(attribute.DisplayEndOfCompilationMessage, errorFile), cancellationToken: cancellationToken); CompilationUnitSyntax generatedRoot = generatedSyntaxTree.GetCompilationUnitRoot(cancellationToken); ClassDeclarationSyntax classSyntax = (ClassDeclarationSyntax)generatedRoot.Members.Last(); ClassDeclarationSyntax originalClassSyntax = classSyntax; // Edit the generated syntax's name, if needed. if (typeName != DebugCometaryAttribute.DefaultMainClassName) { classSyntax = classSyntax.WithIdentifier(F.Identifier(typeName)); } // Change the filename and arguments. SyntaxList <MemberDeclarationSyntax> members = classSyntax.Members; FieldDeclarationSyntax WithValue(FieldDeclarationSyntax node, string value) { VariableDeclaratorSyntax variableSyntax = node.Declaration.Variables[0]; LiteralExpressionSyntax valueSyntax = F.LiteralExpression( SyntaxKind.StringLiteralExpression, F.Literal(value) ); return(node.WithDeclaration( node.Declaration.WithVariables(node.Declaration.Variables.Replace( variableSyntax, variableSyntax.WithInitializer(F.EqualsValueClause(valueSyntax)) )) )); } FieldDeclarationSyntax WithBoolean(FieldDeclarationSyntax node, bool value) { VariableDeclaratorSyntax variableSyntax = node.Declaration.Variables[0]; LiteralExpressionSyntax valueSyntax = F.LiteralExpression(value ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression); return(node.WithDeclaration( node.Declaration.WithVariables(node.Declaration.Variables.Replace( variableSyntax, variableSyntax.WithInitializer(F.EqualsValueClause(valueSyntax)) )) )); } for (int i = 0; i < members.Count; i++) { FieldDeclarationSyntax field = members[i] as FieldDeclarationSyntax; if (field == null) { continue; } string fieldName = field.Declaration.Variables[0].Identifier.Text; switch (fieldName) { case "References": field = WithValue(field, string.Join(";", compilation.References.OfType <PortableExecutableReference>().Select(x => x.FilePath))); break; case "Files": field = WithValue(field, string.Join(";", compilation.SyntaxTrees.Select(x => x.FilePath))); break; case "AssemblyName": field = WithValue(field, compilation.AssemblyName); break; case "ErrorFile": field = WithValue(field, errorFile); break; case "Written": field = WithBoolean(field, OutputAllTreesAttribute.Instance != null); break; case "BreakAtEnd": field = WithBoolean(field, attribute.DisplayEndOfCompilationMessage); break; case "BreakAtStart": field = WithBoolean(field, attribute.BreakDuringStart); break; default: continue; } members = members.Replace(members[i], field); } // Return the modified compilation. return(compilation.AddSyntaxTrees( generatedSyntaxTree .WithCometaryOptions(this) .WithRoot( generatedRoot.WithMembers(generatedRoot.Members.Replace(originalClassSyntax, classSyntax.WithMembers(members)) ) ) )); } CompilationPipeline += EditCompilation; }
public static List <IMethodSymbol> GetTreeMethods(CSharpSyntaxTree tree, SemanticModel model) { return(tree.GetCompilationUnitRoot().DescendantNodes().OfType <MethodDeclarationSyntax>() .Select(p => model.GetDeclaredSymbol(p)) .ToList()); }