public IToken GetUsingStopIndex(CSharpParser.Compilation_unitContext context)
{
return(context?.using_directive()?.LastOrDefault()?.Stop
?? context?.extern_alias_directive()?.LastOrDefault()?.Stop
?? context?.BYTE_ORDER_MARK()?.Symbol
?? context.Start);
}
public override object VisitCompilation_unit([NotNull] CSharpParser.Compilation_unitContext context)
{
var missingUsingDirectives = _cSharpParserService.GetUsingDirectivesNotInContext(
context, new List <string>()
{
_serviceNamespace
});
if (missingUsingDirectives.Count > 0)
{
var usingStopIndex = _cSharpParserService.GetUsingStopIndex(context);
var usingDirectiveStr = _cSharpParserService.GenerateUsingDirectives(
missingUsingDirectives.ToList(),
usingStopIndex.Equals(context.Start));
_isRewritten = true;
Rewriter.InsertAfter(usingStopIndex, usingDirectiveStr);
}
VisitChildren(context);
IsModified = _isRewritten && _isConstructorClassFound;
if (!_isConstructorClassFound)
{
_logger.LogWarning($"No class found called {_constructorClassName} in namespace " +
$"{_constructorClassNamespace}. Failed to inject {_serviceInterfaceType} into class.");
}
return(null);
}
public void Parse(string fileName)
{
CSharpParser.Compilation_unitContext compilationUnit = ParseFile(fileName);
if (compilationUnit.extern_alias_directives() != null)
{
throw new NotSupportedException("Extern alias not supported");
}
if (compilationUnit.global_attribute_section().Length > 0)
{
throw new NotImplementedException("Global attributes are not implemented yet");
}
IUsingStatement[] @using = compilationUnit.using_directives() != null
? compilationUnit.using_directives().Parse()
: new IUsingStatement[0];
Console.WriteLine("Using: " + string.Join <IUsingStatement>(", ", @using));
NamespaceContext @namespace = new NamespaceContext(null, @using);
if (compilationUnit.namespace_member_declarations() != null)
{
compilationUnit.namespace_member_declarations().Parse(@namespace);
}
Console.WriteLine("Done");
}
public override object VisitCompilation_unit([NotNull] CSharpParser.Compilation_unitContext context)
{
VisitChildren(context);
if (IsModified)
{
var missingUsingDirectives = _cSharpParserService.GetUsingDirectivesNotInContext(
context, new List <string>()
{
_breadcrumbServiceNamespace
});
if (missingUsingDirectives.Count > 0)
{
var usingStopIndex = _cSharpParserService.GetUsingStopIndex(context);
var usingDirectiveStr = _cSharpParserService.GenerateUsingDirectives(
missingUsingDirectives.ToList(),
usingStopIndex.Equals(context.Start));
Rewriter.InsertAfter(usingStopIndex, usingDirectiveStr);
}
}
return(null);
}
public override object VisitCompilation_unit([NotNull] CSharpParser.Compilation_unitContext context)
{
_isFoundConfigureServices = false;
var usingNamespaceList = new List <string>();
foreach (var regInfo in _startupRegInfoList)
{
usingNamespaceList.Add(regInfo.ServiceNamespace);
}
var missingUsingDirectives = _cSharpParserService.GetUsingDirectivesNotInContext(
context, usingNamespaceList);
if (missingUsingDirectives.Count > 0)
{
var usingStopIndex = _cSharpParserService.GetUsingStopIndex(context);
var usingDirectiveStr = _cSharpParserService.GenerateUsingDirectives(
missingUsingDirectives.ToList(),
usingStopIndex.Equals(context.Start));
IsModified = true;
Rewriter.InsertAfter(usingStopIndex, usingDirectiveStr);
}
VisitChildren(context);
return(null);
}
static void HandleFileCs(TestVisitor visitor, string filePath)
{
FileInfo info = new FileInfo(filePath);
if (info.Extension == ".cs")
{
AntlrFileStream stream = new AntlrFileStream(filePath);
CSharpLexer lexer = new CSharpLexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CSharpParser parser = new CSharpParser(tokens);
CSharpParser.Compilation_unitContext startContext = parser.compilation_unit();
TestListener listener = new TestListener(parser);
IParseTree tree = parser.compilation_unit();
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(listener, startContext);
StringBuilder streamwritter = new StringBuilder(stream.ToString());
foreach (Tuple <int, string> tup in listener.GetTuples())
{
streamwritter.Remove(tup.Item1, tup.Item2.Length).Insert(tup.Item1, tup.Item2);
}
//visitor.Visit(startContext);
StreamWriter writer = new StreamWriter(filePath);
writer.Write(streamwritter);
writer.Dispose();
}
}
public override void EnterCompilation_unit(CSharpParser.Compilation_unitContext context)
{
var namespaceDeclarationListener = new NamespaceDeclarationMemberListener(OuterClassInfos, FilePath);
foreach (var namespaceMemberDeclaration in context.namespace_member_declarations().namespace_member_declaration())
{
namespaceMemberDeclaration.EnterRule(namespaceDeclarationListener);
}
}
public IToken GetNamespaceStopIndex(CSharpParser.Compilation_unitContext context)
{
return(context?.namespace_member_declaration()?.LastOrDefault()?.Stop
?? context?.global_attributes()?.Stop
?? context?.using_directive()?.LastOrDefault()?.Stop
?? context?.extern_alias_directive()?.LastOrDefault()?.Stop
?? context?.BYTE_ORDER_MARK()?.Symbol
?? context.Start);
}
public void InitOrUpdateParserTreeOfFile(string filePath, string content)
{
//Build Parser tree from content and save it
AntlrInputStream stream = new AntlrInputStream(content);
CSharpLexer lexer = new CSharpLexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CSharpParser parser = new CSharpParser(tokens);
CSharpParser.Compilation_unitContext startContext = parser.compilation_unit();
_parserRuleContextOfFile[filePath] = startContext;
tokenStreams[filePath] = tokens;
}
/// <summary>
/// Create TreeNode from stream
/// </summary>
/// <param name="stream"></param>
/// <param name="tree"></param>
private static void GetTreeFromStream(ICharStream stream, TreeNode tree)
{
CSharpLexer lexer = new CSharpLexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CSharpParser parser = new CSharpParser(tokens);
CSharpParser.Compilation_unitContext startContext = parser.compilation_unit();
Listener listener = new Listener(tree);
IParseTree parserTree = parser.compilation_unit();
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(listener, startContext);
}
public override object VisitCompilation_unit([NotNull] CSharpParser.Compilation_unitContext context)
{
HasServiceClass = false;
Results.ServiceNamespace = _serviceNamespace;
foreach (var usingDirective in context.using_directive())
{
Results.UsingDirectives.Add(
_cSharpParserService.GetTextWithWhitespaceMinifiedLite(
Tokens, usingDirective.using_directive_inner()));
}
VisitChildren(context);
return(null);
}
static void HandleFileCs(TestListener listener, string filePath)
{
FileInfo info = new FileInfo(filePath);
if (info.Extension == ".cs")
{
AntlrFileStream stream = new AntlrFileStream(filePath);
CSharpLexer lexer = new CSharpLexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CSharpParser parser = new CSharpParser(tokens);
parser.RemoveErrorListeners();
parser.AddErrorListener(new CustomError());
CSharpParser.Compilation_unitContext startContext = parser.compilation_unit();
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(listener, startContext);
}
}
public HashSet <string> GetUsingDirectivesNotInContext(
CSharpParser.Compilation_unitContext context,
List <string> usingDirectives)
{
var contextUsingDirectives = context?.using_directive();
var contextUsingSet = new HashSet <string>();
if (contextUsingDirectives != null)
{
foreach (var usingDir in contextUsingDirectives)
{
contextUsingSet.Add(_stringUtilService.MinifyString(usingDir.using_directive_inner().GetText()));
}
}
return(_stringUtilService.GetMissingStrings(contextUsingSet, usingDirectives));
}
public override object VisitCompilation_unit([NotNull] CSharpParser.Compilation_unitContext context)
{
var usingDirs = context?.using_directive();
if (usingDirs != null)
{
foreach (var usingDir in usingDirs)
{
var usingInner = usingDir.using_directive_inner().GetText();
if (_usingSet.Contains(usingInner))
{
_usingSet.Remove(usingInner);
}
}
}
VisitChildren(context);
if (_usingSet.Count > 0)
{
var usingStopIndex = _cSharpParserService.GetUsingStopIndex(context);
var usingDirectivesStr = _cSharpParserService.GenerateUsingDirectives(
_usingSet.ToList(),
usingStopIndex.Equals(context.Start));
IsModified = true;
Rewriter.InsertAfter(usingStopIndex, usingDirectivesStr);
}
if (!_hasBreadcrumbNamespace)
{
var namespaceStopIndex = _cSharpParserService.GetNamespaceStopIndex(context);
var breadcrumbNamespaceDeclaration = _breadcrumbCommandParserService.GenerateBreadcrumbNamespaceDeclaration(
_breadcrumbNamespace,
_breadcrumbDeclaration);
IsModified = true;
Rewriter.InsertAfter(namespaceStopIndex, breadcrumbNamespaceDeclaration);
}
return(null);
}
static void Main(string[] args)
{
List <string> options = new List <string>();
List <string> arguments = new List <string>();
string ast_output_file = null;
CommandLine.Parser.Default.ParseArguments <Options>(args)
.WithParsed <Options>(o =>
{
arguments = o.CsharpFiles.ToList();
ast_output_file = o.AstOutFile;
})
.WithNotParsed(a =>
{
System.Console.Error.WriteLine(a);
});
Runtime.Redirect r = new Runtime.Redirect(ast_output_file);
foreach (var file_name in arguments)
{
var code_as_string = File.ReadAllText(file_name);
var input = new AntlrInputStream(code_as_string);
var lexer = new CSharpLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new CSharpParser(tokens);
var listener = new ErrorListener <IToken>();
parser.AddErrorListener(listener);
CSharpParser.Compilation_unitContext tree = parser.compilation_unit();
if (listener.had_error)
{
return;
}
var sb = new StringBuilder();
var ser = new Runtime.AstHelpers();
ser.ParenthesizedAST(sb, file_name, tree, tokens);
System.Console.Error.WriteLine(sb.ToString());
}
r.Dispose();
}
public override void EnterCompilation_unit([NotNull] CSharpParser.Compilation_unitContext context)
{
}
public override void EnterCompilation_unit([NotNull] CSharpParser.Compilation_unitContext context)
{
this.currentNode = _tree;
base.EnterCompilation_unit(context);
}
public override void EnterCompilation_unit([NotNull] CSharpParser.Compilation_unitContext context)
{
//reset errorTable
errorTable.Clear();
base.EnterCompilation_unit(context);
}
public override void ExitCompilation_unit(CSharpParser.Compilation_unitContext context)
{
Console.WriteLine("Exiting compilation_unit context.");
}
