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());
}
