public virtual List<CSClass> ParseString(string data, string filePath, string projectDirectory, IEnumerable<CSClass> existingClassList) { string relativeFilePath = filePath.Replace(projectDirectory,""); if(relativeFilePath.StartsWith("\\")) { relativeFilePath = relativeFilePath.Substring(1); } List<CSClass> returnValue = new List<CSClass>(existingClassList ?? new CSClass[]{} ); var parser = new CSharpParser(); var compilationUnit = parser.Parse(data, filePath); var namespaceNodeList = compilationUnit.Children.Where(i=>i is NamespaceDeclaration); foreach(NamespaceDeclaration namespaceNode in namespaceNodeList) { var typeDeclarationNodeList = namespaceNode.Children.Where(i=>i is TypeDeclaration); foreach(TypeDeclaration typeDeclarationNode in typeDeclarationNodeList) { var classObject = returnValue.SingleOrDefault(i=>i.ClassName == typeDeclarationNode.Name && i.NamespaceName == namespaceNode.FullName); if(classObject == null) { classObject = new CSClass { NamespaceName = namespaceNode.FullName, ClassName = typeDeclarationNode.Name }; returnValue.Add(classObject); } ClassParser.BuildClass(classObject, typeDeclarationNode, relativeFilePath); } } return returnValue; }
public void GetNodesBetween() { var parser = new CSharpParser(); var expr = parser.ParseExpression("a*b+c*d"); var nodes = expr.GetNodesBetween(1, 3, 1, 6).ToList(); Assert.AreEqual(new[] { "b", "+", "c" }, nodes.Select(n => n.ToString()).ToList()); }
IEntity Lookup(string cref) { string program = @"using System; using System.Collections.Generic; /// <summary/> class Test { int @int; void M(int a) {} void Overloaded(int a) {} void Overloaded(string a) {} void Overloaded(ref int a) {} public int this[int index] { get { return 0; } } public static int operator +(Test a, int b) { return 0; } public static implicit operator Test(int a) { return 0; } public static implicit operator int(Test a) { return 0; } } interface IGeneric<A, B> { void Test<T>(ref T[,] a); } class Impl<T> : IGeneric<List<string>[,], T> { void IGeneric<List<string>[,], T>.Test<X>(ref X[,] a) {} }"; var pc = new CSharpProjectContent().AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib }); var cu = new CSharpParser().Parse(new StringReader(program), "program.cs"); var compilation = pc.UpdateProjectContent(null, cu.ToTypeSystem()).CreateCompilation(); var typeDefinition = compilation.MainAssembly.TopLevelTypeDefinitions.Single(); IEntity entity = typeDefinition.Documentation.ResolveCref(cref); Assert.IsNotNull(entity, "ResolveCref() returned null."); return entity; }
public void TestCollectNodes() { var cu = new CSharpParser().Parse("using System;\nclass Test {\n int field; // comment\n}"); CollectNodesVisitor v = new CollectNodesVisitor(); cu.AcceptVisitor(v); Assert.AreEqual(cu.DescendantsAndSelf.ToList(), v.nodes); }
public static List<CSharpClassAst> GetCSharpClasses(this AssignmentStatementAst ast) { var result = new List<CSharpClassAst>(); var parser = new CSharpParser(); foreach (var str in ast.Right.FindAll(x => x is StringConstantExpressionAst,true)) { var value = ((StringConstantExpressionAst)str).Value; var syntaxTree = parser.Parse(value); if (!syntaxTree.Errors.Any()) foreach (var child in syntaxTree.Children) { var tree = child as TypeDeclaration; if (tree != null) { if (tree.ClassType == ClassType.Class) result.Add(new CSharpClassAst(tree, (StringConstantExpressionAst)str)); } } } return result; }
public static ICSharpCode.NRefactory.CSharp.CompilationUnit Parse(this ICSharpCode.NRefactory.CSharp.CSharpParser parser, TextEditorData data) { using (var stream = data.OpenStream()) { return(parser.Parse(stream, data.Document.FileName)); } }
public SemanticErrorsResponse FindSemanticErrors(Request request) { var clientFilename = request.FileName.ApplyPathReplacementsForClient(); var project = _solution.ProjectContainingFile(request.FileName); project.UpdateFile(request.FileName, request.Buffer); var solutionSnapshot = new DefaultSolutionSnapshot(_solution.Projects.Select(i => i.ProjectContent)); SyntaxTree syntaxTree; if(project.CompilerSettings!=null){ syntaxTree = new CSharpParser(project.CompilerSettings).Parse(request.Buffer, request.FileName); }else{ syntaxTree = new CSharpParser().Parse(request.Buffer, request.FileName); } var resolver = new CSharpAstResolver(solutionSnapshot.GetCompilation(project.ProjectContent), syntaxTree); var navigator = new SemanticErrorsNavigator(); resolver.ApplyNavigator(navigator); var errors = navigator.GetErrors() .Where(e => ShouldIncludeIssue(e.Message)) .Select(i => new Error { FileName = clientFilename, Message = i.Message, Line = i.StartLocation.Line, Column = i.EndLocation.Column, EndLine = i.EndLocation.Line, EndColumn = i.EndLocation.Column }); return new SemanticErrorsResponse { Errors = errors, }; }
public static IEnumerable<ICompletionData> DoCodeComplete(string editorText, int offset) // not the best way to put in the whole string every time { var doc = new ReadOnlyDocument(editorText); var location = doc.GetLocation(offset); string parsedText = editorText; // TODO: Why are there different values in test cases? var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs"); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); var mb = new DefaultCompletionContextProvider(doc, unresolvedFile); IProjectContent pctx = new CSharpProjectContent(); var refs = new List<IUnresolvedAssembly> { mscorlib.Value, systemCore.Value, systemAssembly.Value }; pctx = pctx.AddAssemblyReferences(refs); pctx = pctx.AddOrUpdateFiles(unresolvedFile); var cmp = pctx.CreateCompilation(); var resolver3 = unresolvedFile.GetResolver(cmp, location); var engine = new CSharpCompletionEngine(doc, mb, new TestCompletionDataFactory(resolver3), pctx, resolver3.CurrentTypeResolveContext); engine.EolMarker = Environment.NewLine; engine.FormattingPolicy = FormattingOptionsFactory.CreateMono(); var data = engine.GetCompletionData(offset, controlSpace: false); return data; }
string ConvertExpression(string code) { CSharpParser parser = new CSharpParser(); var expr = parser.ParseExpression(code); Assert.IsFalse(parser.HasErrors); return ConvertExpression(expr); }
private static string FormatInternal(string code) { var cSharpParser = new CSharpParser(); var expr = cSharpParser.ParseExpression(code); if (cSharpParser.HasErrors) { throw new ArgumentException(string.Join(Environment.NewLine, cSharpParser.Errors.Select(e => e.ErrorType + " " + e.Message + " " + e.Region))); } // Wrap expression in parenthesized expression, this is necessary because the transformations // can't replace the root node of the syntax tree expr = new ParenthesizedExpression(expr); // Apply transformations new IntroduceQueryExpressions().Run(expr); new CombineQueryExpressions().Run(expr); new IntroduceParenthesisForNestedQueries().Run(expr); new RemoveQueryContinuation().Run(expr); // Unwrap expression expr = ((ParenthesizedExpression)expr).Expression; var format = expr.GetText(FormattingOptionsFactory.CreateAllman()); if (format.Substring(0, 3) == "\r\n\t") { format = format.Remove(0, 3); } format = format.Replace("\r\n\t", "\n"); return(format); }
public void ParseAndWrite(PARSE_TYPE type, string inputText) { // parse through framework SyntaxTree tree = new N.CSharpParser().Parse(inputText); // dispatch to visitor var defaultVisitor = new NRefactoryVisitor(); tree.AcceptVisitor(defaultVisitor); IEnumerable<CLRType> CLRTypesDetected = defaultVisitor.CLRTypes; switch (type) { case PARSE_TYPE.FIELDS: CLRTypesDetected.ToList().ForEach(clrType => clrType.WriteFieldsUML(m_richSb)); break; case PARSE_TYPE.PROPERTIES: CLRTypesDetected.ToList().ForEach(clrType => clrType.WritePropertiesUML(m_richSb)); break; case PARSE_TYPE.METHODS: CLRTypesDetected.ToList().ForEach(clrType => clrType.WriteMethodsUML(m_richSb)); break; case PARSE_TYPE.ALL: CLRTypesDetected.ToList().ForEach(clrType => clrType.Design(m_richSb)); break; default: throw new NotSupportedException(); } }
protected override void Run () { MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument; CSharpParser parser = new CSharpParser (); var unit = parser.Parse (doc.Editor); if (unit == null) return; var node = unit.GetNodeAt (doc.Editor.Caret.Line, doc.Editor.Caret.Column); if (node == null) return; Stack<AstNode > nodeStack = new Stack<AstNode> (); nodeStack.Push (node); if (doc.Editor.IsSomethingSelected) { while (node != null && doc.Editor.MainSelection.IsSelected (node.StartLocation.Line, node.StartLocation.Column, node.EndLocation.Line, node.EndLocation.Column)) { node = node.Parent; if (node != null) { if (nodeStack.Count > 0 && nodeStack.Peek ().StartLocation == node.StartLocation && nodeStack.Peek ().EndLocation == node.EndLocation) nodeStack.Pop (); nodeStack.Push (node); } } } if (nodeStack.Count > 2) { nodeStack.Pop (); // parent nodeStack.Pop (); // current node node = nodeStack.Pop (); // next children in which the caret is doc.Editor.SetSelection (node.StartLocation.Line, node.StartLocation.Column, node.EndLocation.Line, node.EndLocation.Column); } else { doc.Editor.ClearSelection (); } }
public MethodResult ExtractPrototypeAndMethod(string code) { Guard.AgainstNullArgument("code", code); var @class = "class A { " + code + " } "; var visitor = new MethodVisitor(); var parser = new CSharpParser(); var syntaxTree = parser.Parse(@class); syntaxTree.AcceptVisitor(visitor); syntaxTree.Freeze(); var result = visitor.GetMethodDeclarations().FirstOrDefault(); // find newlines in method signature to maintain linenumbers var newLines = code.Substring(0, code.IndexOf("{", StringComparison.Ordinal) - 1) .Where(x => x.Equals('\n')) .Aggregate(string.Empty, (a, c) => a + c); // use code methodblock to maintain linenumbers var codeBlock = code.Substring(code.IndexOf("{", StringComparison.Ordinal), code.LastIndexOf("}", StringComparison.Ordinal) - code.IndexOf("{", StringComparison.Ordinal) + 1); var method = result.MethodExpression.ToString(); var blockStart = method.IndexOf("{", StringComparison.Ordinal); var blockEnd = method.LastIndexOf("}", StringComparison.Ordinal); method = method.Remove(blockStart, blockEnd - blockStart + 1); method = method.Insert(blockStart, codeBlock); return new MethodResult { ProtoType = result.MethodPrototype.ToString().Trim() + newLines, MethodExpression = newLines + method.Trim() }; }
protected void Prepare(string source, bool minimizeNames = true, bool expectErrors = false) { IProjectContent project = new CSharpProjectContent(); var parser = new CSharpParser(); using (var rdr = new StringReader(source)) { var pf = new CSharpUnresolvedFile { FileName = "File.cs" }; var syntaxTree = parser.Parse(rdr, pf.FileName); syntaxTree.AcceptVisitor(new TypeSystemConvertVisitor(pf)); project = project.AddOrUpdateFiles(pf); } project = project.AddAssemblyReferences(new[] { Files.Mscorlib }); _errorReporter = new MockErrorReporter(!expectErrors); var compilation = project.CreateCompilation(); var s = new AttributeStore(compilation, _errorReporter); RunAutomaticMetadataAttributeAppliers(s, compilation); s.RunAttributeCode(); Metadata = new MetadataImporter(_errorReporter, compilation, s, new CompilerOptions { MinimizeScript = minimizeNames }); Metadata.Prepare(compilation.GetAllTypeDefinitions()); AllErrors = _errorReporter.AllMessages.ToList().AsReadOnly(); AllErrorTexts = _errorReporter.AllMessages.Select(m => m.FormattedMessage).ToList().AsReadOnly(); if (expectErrors) { Assert.That(AllErrorTexts, Is.Not.Empty, "Compile should have generated errors"); } else { Assert.That(AllErrorTexts, Is.Empty, "Compile should not generate errors"); } AllTypes = compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).ToDictionary(t => t.ReflectionName); }
string ConvertStatement(string code) { CSharpParser parser = new CSharpParser(); var expr = parser.ParseStatements(new StringReader(code)).Single(); Assert.IsFalse(parser.HasErrors); return ConvertStatement(expr); }
void Init(string program) { var pc = new CSharpProjectContent().AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib }); var cu = new CSharpParser().Parse(new StringReader(program), "program.cs"); compilation = pc.UpdateProjectContent(null, cu.ToTypeSystem()).CreateCompilation(); typeDefinition = compilation.MainAssembly.TopLevelTypeDefinitions.FirstOrDefault(); }
public string Parse(PARSE_TYPE type, string inputText) { // parse through framework SyntaxTree tree = new N.CSharpParser().Parse(inputText); // dispatch to visitor var defaultVisitor = new NRefactoryVisitor(); tree.AcceptVisitor(defaultVisitor); IEnumerable<CLRType> inputTextTypes = defaultVisitor.CLRTypes; switch (type) { case PARSE_TYPE.FIELDS: return inputTextTypes.Aggregate(new StringBuilder(), (sb, clr) => sb.AppendLine(clr.GetFieldsUML())).ToString(); case PARSE_TYPE.PROPERTIES: return inputTextTypes.Aggregate(new StringBuilder(), (sb, clr) => sb.AppendLine(clr.GetPropertiesUML())).ToString(); case PARSE_TYPE.METHODS: return inputTextTypes.Aggregate(new StringBuilder(), (sb, clr) => sb.AppendLine(clr.GetMethodsUML())).ToString(); case PARSE_TYPE.ALL: return inputTextTypes.Aggregate(new StringBuilder(), (sb, clr) => sb.AppendLine(clr.Design())).ToString(); default: throw new NotSupportedException(); } }
public static bool CheckSyntax(string expression, out Error[] errors) { var p = new CSharpParser(); p.ParseExpression(expression); errors = p.Errors.ToArray(); return !errors.Any(); }
protected void BuildSyntaxTree() { for (int i = 0; i < this.SourceFiles.Count; i++) { var fileName = this.SourceFiles[i]; using (var reader = new StreamReader(fileName)) { var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser(); if (!string.IsNullOrEmpty(Defines)) { string[] defs = Defines.Split(';'); foreach (string def in defs) { parser.CompilerSettings.ConditionalSymbols.Add(def); } } if (this.DefineConstants != null && this.DefineConstants.Count > 0) { foreach (var defineConstant in this.DefineConstants) { parser.CompilerSettings.ConditionalSymbols.Add(defineConstant); } } var syntaxTree = parser.Parse(reader, fileName); if (parser.HasErrors) { foreach (var error in parser.Errors) { throw new EmitterException(syntaxTree, string.Format("Parsing error in a file {0} {2}: {1}", fileName, error.Message, error.Region.Begin.ToString())); } } var expandResult = new QueryExpressionExpander().ExpandQueryExpressions(syntaxTree); syntaxTree = (expandResult != null ? (SyntaxTree)expandResult.AstNode : syntaxTree); var emptyLambdaDetecter = new EmptyLambdaDetecter(); syntaxTree.AcceptVisitor(emptyLambdaDetecter); if (emptyLambdaDetecter.Found) { var fixer = new EmptyLambdaFixer(); var astNode = syntaxTree.AcceptVisitor(fixer); syntaxTree = (astNode != null ? (SyntaxTree)astNode : syntaxTree); } var f = new ParsedSourceFile(syntaxTree, new CSharpUnresolvedFile { FileName = fileName }); this.ParsedSourceFiles.Add(f); var tcv = new TypeSystemConvertVisitor(f.ParsedFile); f.SyntaxTree.AcceptVisitor(tcv); } } }
public static void Main(string[] args) { var server = new TcpListener(IPAddress.Loopback, 5556); server.Start(); while (true) { var newClient = server.AcceptTcpClient(); Console.WriteLine("Got new client."); using (var clientStream = newClient.GetStream()) { var request = CSharpParseRequest.ParseDelimitedFrom(clientStream); Console.WriteLine("Starting collecting AST for:\n"); Console.WriteLine(request.Filename); var parser = new CSharpParser(); var csFile = new FileStream(request.Filename, FileMode.Open); var cu = parser.Parse(csFile); var resultBuilder = CSharpParseResult.CreateBuilder(); foreach (var child in cu.Children) { var builder = Landman.Rascal.CSharp.Profobuf.AstNode.CreateBuilder(); GenerateNode(child, builder); resultBuilder.AddResult(builder); } resultBuilder.Build().WriteDelimitedTo(clientStream); Console.WriteLine("\nFinished"); } } }
public static string GetMethodBody(string sourceFilePath, string methodName, int callingLine) { if (!File.Exists(sourceFilePath)) return string.Format("{0} file not found.", Path.GetFileName(sourceFilePath)); try { var parser = new CSharpParser(); var syntaxTree = parser.Parse(File.ReadAllText(sourceFilePath)); var result = syntaxTree.Descendants.OfType<MethodDeclaration>() .FirstOrDefault(y => y.NameToken.Name == methodName && y.EndLocation.Line > callingLine); if (result != null) { return result.ToString(FormattingOptionsFactory.CreateSharpDevelop()).Trim(); } result = syntaxTree.Descendants.OfType<MethodDeclaration>() .FirstOrDefault(y => y.NameToken.Name == methodName); if (result != null) { return result.ToString(FormattingOptionsFactory.CreateSharpDevelop()).Trim(); } } catch { return readLines(sourceFilePath, callingLine); } return readLines(sourceFilePath, callingLine); }
public void TestCapturedForeachInCSharp5() { var parser = new CSharpParser(); var tree = parser.Parse(@" using System; class TestClass { void TestMethod() { int? accum = 0; foreach (var x in new int?[] { 1, 2, 3 }) { Action action = () => { x = null; }; accum += x; } } } ", "test.cs"); Assert.AreEqual(0, tree.Errors.Count); var method = tree.Descendants.OfType<MethodDeclaration>().Single(); var analysis = CreateNullValueAnalysis(tree, method, true); var foreachStatement = (ForeachStatement)method.Body.Statements.ElementAt(1); var foreachBody = (BlockStatement)foreachStatement.EmbeddedStatement; var action = foreachBody.Statements.First(); var lastStatement = method.Body.Statements.Last(); Assert.AreEqual(NullValueStatus.Unknown, analysis.GetVariableStatusBeforeStatement(action, "x")); Assert.AreEqual(NullValueStatus.CapturedUnknown, analysis.GetVariableStatusAfterStatement(action, "x")); Assert.AreEqual(NullValueStatus.Unknown, analysis.GetVariableStatusAfterStatement(lastStatement, "accum")); }
static void Main(string[] args) { var gitPath = ConfigurationManager.AppSettings["GitPath"]; var gitCommitIterator = new GitCommitIterator(gitPath); var gitWorkingCopyCheckout = new GitWorkingCopyCheckout(gitPath); var workingCopyPath = args[0]; var analysisOutputPath = Path.Combine(Environment.CurrentDirectory, "analysis"); EnsureCleanAnalysisOutput(analysisOutputPath); var parser = new CSharpParser(); foreach (var commit in gitCommitIterator.GetCommits(workingCopyPath)) { Console.WriteLine(commit); gitWorkingCopyCheckout.CheckoutCommit(workingCopyPath, commit); using (var output = File.OpenWrite( Path.Combine( analysisOutputPath, commit.AnalysisOutputFileName))) { using (var csvWriter = new StreamWriter(output)) { CSharpMethod.WriteCsvHeader(csvWriter); foreach (var file in CSharpFile.Enumerate(workingCopyPath, commit)) { foreach (var method in file.AnalyzeMethods(parser)) { method.WriteAsCsv(csvWriter); } } csvWriter.Flush(); } } } Console.WriteLine("Yeah, I'm done."); Console.ReadLine(); }
public static void ClassInitialize(TestContext context) { Token[] psTokens; ParseError[] psErrors; var ast = Parser.ParseFile(Path.Combine(context.DeploymentDirectory, ExpectationsFile), out psTokens, out psErrors); var items = ast.EndBlock.FindAll(m => m is AssignmentStatementAst, false); Expectations = new Dictionary<string, string>(); foreach (AssignmentStatementAst item in items) { var variableExpression = item.Left as VariableExpressionAst; var scriptBlockAst = item.Right.Find(m => m is ScriptBlockAst, true) as ScriptBlockAst; if (variableExpression != null && scriptBlockAst != null) { Expectations.Add(variableExpression.VariablePath.UserPath, scriptBlockAst.Extent.ToString().Trim('}', '{').Trim()); } } TestData = new Dictionary<string, string>(); var parser = new CSharpParser(); var syntaxTree = parser.Parse(File.ReadAllText(Path.Combine(context.DeploymentDirectory, TestDataFile))); foreach (NamespaceDeclaration namespaceDeclaration in syntaxTree.Members.Where(m => m is NamespaceDeclaration)) { TestData.Add(namespaceDeclaration.FullName, namespaceDeclaration.ToString()); } }
public ParseInformation Parse(FileName fileName, ITextSource fileContent, bool fullParseInformationRequested, IProject parentProject, CancellationToken cancellationToken) { var csharpProject = parentProject as CSharpProject; CSharpParser parser = new CSharpParser(csharpProject != null ? csharpProject.CompilerSettings : null); parser.GenerateTypeSystemMode = !fullParseInformationRequested; SyntaxTree cu = parser.Parse(fileContent, fileName); cu.Freeze(); CSharpUnresolvedFile file = cu.ToTypeSystem(); ParseInformation parseInfo; if (fullParseInformationRequested) parseInfo = new CSharpFullParseInformation(file, fileContent.Version, cu); else parseInfo = new ParseInformation(file, fileContent.Version, fullParseInformationRequested); IDocument document = fileContent as IDocument; AddCommentTags(cu, parseInfo.TagComments, fileContent, parseInfo.FileName, ref document); if (fullParseInformationRequested) { if (document == null) document = new ReadOnlyDocument(fileContent, parseInfo.FileName); ((CSharpFullParseInformation)parseInfo).newFoldings = CreateNewFoldings(cu, document); } return parseInfo; }
IUnresolvedFile Parse(string fileName, string code) { var parser = new CSharpParser(); var syntaxTree = parser.Parse(code, fileName); Assert.IsFalse(parser.HasErrors); return syntaxTree.ToTypeSystem(); }
public ParseResult Parse(string code) { var result = new ParseResult(); var parser = new CSharpParser(); var syntaxTree = parser.Parse(code); var codeLines = code.Split(new[] { Environment.NewLine }, StringSplitOptions.None); var codeLinesDictionary = new Dictionary<int, Tuple<string, bool>>(); for (int i = 0; i < codeLines.Length; i++) { codeLinesDictionary.Add(i, new Tuple<string, bool>(codeLines[i], true)); } var typeMembersTree = parser.ParseTypeMembers(code); foreach (var typeMember in typeMembersTree.Where(x => x is TypeDeclaration || x is MethodDeclaration)) { var element = typeMember.GetText(); if (typeMember is TypeDeclaration) { result.Declarations += element; } //else //{ // result.Declarations += "public static partial ScriptCsMethod {"; // result.Declarations += element; // result.Declarations += "}"; //} for (var i = typeMember.StartLocation.Line - 1; i < typeMember.StartLocation.Line; i++) { var oldItem = codeLinesDictionary[i]; codeLinesDictionary[i] = new Tuple<string, bool>(oldItem.Item1, false); } } var keysToRemove = codeLinesDictionary.Where(x => x.Value.Item2 == false).Select(i => i.Key); keysToRemove.ToList().ForEach(x => codeLinesDictionary.Remove(x)); foreach (var correct in syntaxTree.Members) { var element = correct.GetText(); ; result.Declarations += element; } if (syntaxTree.Errors.Any()) { var evalLines = codeLines.Skip(syntaxTree.Errors.First().Region.BeginLine - 1).ToList(); result.Evaluations += string.Join(Environment.NewLine, evalLines); //result.Evaluations = "public void ScriptCsInvoke() {" + Environment.NewLine; //result.Evaluations = string.Join(Environment.NewLine, codeLinesDictionary.Select(i => i.Value.Item1)); //result.Evaluations += Environment.NewLine + "}"; } var evaluationTree = parser.ParseStatements(result.Evaluations); return result; }
public ConvertionResult ToKnockoutVm(string code, TranslateOptions options = null) { if(options == null) { options = TranslateOptions.Defaults; } _log.Debug("Converting code to Knockout VM. Options:\n{0}\nCode:\n{1}", options.ToFormattedJson(), code); Func<ConvertionResult, ConvertionResult> exit = r => { _log.Debug("Returning Convertion Result: {0}", r.ToFormattedJson()); return r; }; var result = new ConvertionResult(); if(code.IsNullOrEmpty()) { result.Success = false; result.Message = "No code provided"; return exit(result); } // do convertion code = code.AddDefaultUsings(); var visitor = new NRefactoryVisitor(options); var textReader = new StringReader(code); var parser = new CSharpParser(); var cu = parser.Parse(textReader, "dummy.cs"); if(parser.HasErrors) { var errors = cu.GetErrors(); var warnings = cu.GetErrors(ErrorType.Warning); result.Success = false; result.Message = "Error parsing code file."; result.Errors.AddRange(errors); result.Warnings.AddRange(warnings); return exit(result); } if(parser.HasWarnings) { var warnings = cu.GetErrors(ErrorType.Warning); result.Message = "Parsed code contains warnings!"; result.Warnings.AddRange(warnings); } cu.AcceptVisitor(visitor); var writter = new KnockoutWritter(); var convertedCode = writter.Write(visitor.Result, options); result.Success = true; result.Code = convertedCode; return exit(result); }
public void AddMethod(string methodCode) { var parser = new CSharpParser(); var syntaxTree = parser.Parse("public class Foo{" + methodCode + "}"); var method = syntaxTree.Children.First().Children.First(x => x is MethodDeclaration).Clone(); tree.AddChild<EntityDeclaration>((EntityDeclaration)method, Roles.TypeMemberRole); }
void Init(string program) { pc = new IDStringTestProjectContent(); var cu = new CSharpParser().Parse(new StringReader(program)); var parsedFile = new TypeSystemConvertVisitor(pc, "program.cs").Convert(cu); pc.UpdateProjectContent(null, parsedFile); }
/// <summary> /// Formats the specified part of the document. /// </summary> public static void Format(IDocument document, int offset, int length, CSharpFormattingOptions options) { var syntaxTree = new CSharpParser().Parse(document); var fv = new AstFormattingVisitor(options, document); fv.FormattingRegion = new DomRegion(document.GetLocation(offset), document.GetLocation(offset + length)); syntaxTree.AcceptVisitor(fv); fv.ApplyChanges(offset, length); }
private static CSharpParser CreateParser(IEnumerable<string> defineConstants) { var parser = new CSharpParser(); if (defineConstants != null) { foreach (var c in defineConstants) parser.CompilerSettings.ConditionalSymbols.Add(c); } return parser; }
protected static TypeDeclaration ParseType(string code) { var cSharpParser = new CSharpParser(); var tree = cSharpParser.Parse(code); Assert.AreEqual(0, tree.Errors.Count, tree.Errors.Aggregate("", (s, e) => s + e.Message + "\r\n")); var type = tree.GetTypes().Single(); return (TypeDeclaration)type; }
private SyntaxTree ReadSyntaxTree(Stream stream) { using (var streamReader = new StreamReader(stream)) { var codeParser = new CSharpParser(); return(codeParser.Parse(streamReader)); } }
public ParsedDocument Parse(bool storeAst, string fileName, System.IO.TextReader content, MonoDevelop.Projects.Project project = null) { var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser(GetCompilerArguments(project)); parser.GenerateTypeSystemMode = !storeAst; var result = new ParsedDocumentDecorator(); if (project != null) { var projectFile = project.Files.GetFile(fileName); if (projectFile != null && projectFile.BuildAction != BuildAction.Compile) { result.Flags |= ParsedDocumentFlags.NonSerializable; } } var tagComments = CommentTag.SpecialCommentTags.Select(t => t.Tag).ToArray(); parser.CompilationUnitCallback = delegate(CompilerCompilationUnit top) { foreach (var special in top.SpecialsBag.Specials) { var comment = special as SpecialsBag.Comment; if (comment != null) { VisitComment(result, comment, tagComments); } else { if (storeAst) { VisitPreprocessorDirective(result, special as SpecialsBag.PreProcessorDirective); } } } }; var unit = parser.Parse(content, fileName); unit.Freeze(); var pf = unit.ToTypeSystem(); try { pf.LastWriteTime = System.IO.File.GetLastWriteTimeUtc(fileName); } catch (Exception) { pf.LastWriteTime = DateTime.UtcNow; } result.LastWriteTimeUtc = pf.LastWriteTime.Value; result.ParsedFile = pf; result.Add(GenerateFoldings(unit, result)); if (storeAst) { result.Ast = unit; } return(result); }
protected virtual SyntaxTree GetSyntaxTree(string fileName) { using (var reader = new StreamReader(fileName)) { var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser(); var syntaxTree = parser.Parse(reader, fileName); if (parser.HasErrors) { foreach (var error in parser.Errors) { Bridge.Translator.Exception.Throw("Parsing error in a file {0} {2}: {1}", fileName, error.Message, error.Region.Begin.ToString()); } } return(syntaxTree); } }
public void AnalyzeCSharpProject(string path) { mappers = new ArrayList(); b = new StringBuilder(); path = Path.GetDirectoryName(path); path = Path.GetFullPath(path); ICSharpCode.NRefactory.CSharp.CSharpParser parse = new ICSharpCode.NRefactory.CSharp.CSharpParser(); string[] tree = Directory.GetFiles(path, "*.cs", SearchOption.AllDirectories); int i = 0; foreach (string s in tree) { AnalyzeCSharpFile(s); //if (i > 2000) // break; i++; } //string p = b.ToString(); //File.WriteAllText("code-class.txt", p); // ICSharpCode.NRefactory.Utils.FastSerializer fs = new ICSharpCode.NRefactory.Utils.FastSerializer(); // Persist to file FileStream stream = File.Create("dict.txt"); BinaryFormatter formatter = new BinaryFormatter(); Console.WriteLine("Serializing vector"); formatter.Serialize(stream, wm.sharedDict); stream.Close(); }
public static AstNode ParseSnippet(this ICSharpCode.NRefactory.CSharp.CSharpParser parser, TextEditorData data) { using (var stream = new StreamReader(data.OpenStream())) { var result = parser.ParseExpression(stream); if (!parser.HasErrors) { return(result); } } parser.ErrorPrinter.Reset(); using (var stream = new StreamReader(data.OpenStream())) { var result = parser.ParseStatements(stream); if (!parser.HasErrors) { return(result.First()); } } parser.ErrorPrinter.Reset(); using (var stream = data.OpenStream()) { return(parser.Parse(stream)); } }
protected void BuildSyntaxTree() { this.Log.Info("Building syntax tree..."); var rewriter = new SharpSixRewriter(this); for (int i = 0; i < this.SourceFiles.Count; i++) { var fileName = this.SourceFiles[i]; this.Log.Trace("Source file " + (fileName ?? string.Empty) + " ..."); var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser(); if (this.DefineConstants != null && this.DefineConstants.Count > 0) { foreach (var defineConstant in this.DefineConstants) { parser.CompilerSettings.ConditionalSymbols.Add(defineConstant); } } var syntaxTree = parser.Parse(rewriter.Rewrite(i), fileName); syntaxTree.FileName = fileName; //var syntaxTree = parser.Parse(reader, fileName); this.Log.Trace("\tParsing syntax tree done"); if (parser.HasErrors) { foreach (var error in parser.Errors) { throw new EmitterException(syntaxTree, string.Format("Parsing error in a file {0} {2}: {1}", fileName, error.Message, error.Region.Begin.ToString())); } } var expandResult = new QueryExpressionExpander().ExpandQueryExpressions(syntaxTree); this.Log.Trace("\tExpanding query expressions done"); syntaxTree = (expandResult != null ? (SyntaxTree)expandResult.AstNode : syntaxTree); var emptyLambdaDetecter = new EmptyLambdaDetecter(); syntaxTree.AcceptVisitor(emptyLambdaDetecter); this.Log.Trace("\tAccepting lambda detector visitor done"); if (emptyLambdaDetecter.Found) { var fixer = new EmptyLambdaFixer(); var astNode = syntaxTree.AcceptVisitor(fixer); this.Log.Trace("\tAccepting lambda fixer visitor done"); syntaxTree = (astNode != null ? (SyntaxTree)astNode : syntaxTree); syntaxTree.FileName = fileName; } var f = new ParsedSourceFile(syntaxTree, new CSharpUnresolvedFile { FileName = fileName }); this.ParsedSourceFiles.Add(f); var tcv = new TypeSystemConvertVisitor(f.ParsedFile); f.SyntaxTree.AcceptVisitor(tcv); this.Log.Trace("\tAccepting type system convert visitor done"); this.Log.Trace("Source file " + (fileName ?? string.Empty) + " done"); } this.Log.Info("Building syntax tree done"); }
public override ParsedDocument Parse(bool storeAst, string fileName, System.IO.TextReader content, MonoDevelop.Projects.Project project = null) { var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser(GetCompilerArguments(project)); parser.GenerateTypeSystemMode = !storeAst; var result = new ParsedDocumentDecorator(); if (project != null) { var projectFile = project.Files.GetFile(fileName); if (projectFile != null && !TypeSystemParserNode.IsCompileBuildAction(projectFile.BuildAction)) { result.Flags |= ParsedDocumentFlags.NonSerializable; } } var tagComments = CommentTag.SpecialCommentTags.Select(t => t.Tag).ToArray(); parser.CompilationUnitCallback = delegate(CompilerCompilationUnit top) { foreach (var special in top.SpecialsBag.Specials) { var comment = special as SpecialsBag.Comment; if (comment != null) { VisitComment(result, comment, tagComments); } else { if (storeAst) { var ppd = special as SpecialsBag.PreProcessorDirective; if (ppd != null) { VisitPreprocessorDirective(result, ppd); } } } } }; var unit = parser.Parse(content, fileName); unit.Freeze(); var pf = unit.ToTypeSystem(); try { pf.LastWriteTime = System.IO.File.GetLastWriteTimeUtc(fileName); } catch (Exception) { pf.LastWriteTime = DateTime.UtcNow; } result.LastWriteTimeUtc = pf.LastWriteTime.Value; result.ParsedFile = pf; result.Add(GetSemanticTags(unit)); result.CreateRefactoringContext = delegate(MonoDevelop.Ide.Gui.Document doc, System.Threading.CancellationToken token) { var task = MDRefactoringContext.Create(doc, doc.Editor.Caret.Location, token); task.Wait(5000, token); if (!task.IsCompleted) { return(null); } return(task.Result); }; result.CreateRefactoringContextWithEditor = (data, resolver, token) => new MDRefactoringContext((DotNetProject)project, data, result, (CSharpAstResolver)resolver, TextLocation.Empty, token); if (storeAst) { result.Ast = unit; result.Add(GenerateFoldings(unit, result)); } return(result); }
private void LoadSytanxTree(string sourceCode) { CSharpParser csParser = new CSharpParser(); syntaxTree = csParser.Parse(sourceCode); }
private void BuildSyntaxTreeForFile(int index, ref string[] rewriten) { var fileName = this.SourceFiles[index]; this.Log.Trace("Source file " + (fileName ?? string.Empty) + " ..."); var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser(); if (this.DefineConstants != null && this.DefineConstants.Count > 0) { foreach (var defineConstant in this.DefineConstants) { parser.CompilerSettings.ConditionalSymbols.Add(defineConstant); } } var syntaxTree = parser.Parse(rewriten[index], fileName); syntaxTree.FileName = fileName; this.Log.Trace("\tParsing syntax tree done"); if (parser.HasErrors) { var errors = new List <string>(); foreach (var error in parser.Errors) { errors.Add(fileName + ":" + error.Region.BeginLine + "," + error.Region.BeginColumn + ": " + error.Message); } throw new EmitterException(syntaxTree, "Error parsing code." + Environment.NewLine + String.Join(Environment.NewLine, errors)); } var expandResult = new QueryExpressionExpander().ExpandQueryExpressions(syntaxTree); this.Log.Trace("\tExpanding query expressions done"); syntaxTree = (expandResult != null ? (SyntaxTree)expandResult.AstNode : syntaxTree); var emptyLambdaDetecter = new EmptyLambdaDetecter(); syntaxTree.AcceptVisitor(emptyLambdaDetecter); this.Log.Trace("\tAccepting lambda detector visitor done"); if (emptyLambdaDetecter.Found) { var fixer = new EmptyLambdaFixer(); var astNode = syntaxTree.AcceptVisitor(fixer); this.Log.Trace("\tAccepting lambda fixer visitor done"); syntaxTree = (astNode != null ? (SyntaxTree)astNode : syntaxTree); syntaxTree.FileName = fileName; } var f = new ParsedSourceFile(syntaxTree, new CSharpUnresolvedFile { FileName = fileName }); this.ParsedSourceFiles[index] = f; var tcv = new TypeSystemConvertVisitor(f.ParsedFile); f.SyntaxTree.AcceptVisitor(tcv); this.Log.Trace("\tAccepting type system convert visitor done"); this.Log.Trace("Source file " + (fileName ?? string.Empty) + " done"); }
public static void Format(PolicyContainer policyParent, IEnumerable <string> mimeTypeChain, MonoDevelop.Ide.Gui.Document data, ProjectDom dom, DomLocation location, bool correctBlankLines, bool runAferCR /* = false*/) { if (data.ParsedDocument == null || data.ParsedDocument.CompilationUnit == null) { return; } var member = data.ParsedDocument.CompilationUnit.GetMemberAt(location.Line + (runAferCR ? -1 : 0), location.Column); if (member == null || member.Location.IsEmpty || member.BodyRegion.End.IsEmpty) { return; } StringBuilder sb = new StringBuilder(); int closingBrackets = 0; DomRegion validRegion = DomRegion.Empty; foreach (var u in data.ParsedDocument.CompilationUnit.Usings.Where(us => us.IsFromNamespace)) { // the dom parser breaks A.B.C into 3 namespaces with the same region, this is filtered here if (u.ValidRegion == validRegion || !u.ValidRegion.Contains(location)) { continue; } // indicates a parser error on namespace level. if (u.Namespaces.FirstOrDefault() == "<invalid>") { continue; } validRegion = u.ValidRegion; sb.Append("namespace Stub {"); sb.Append(data.Editor.EolMarker); closingBrackets++; } var parent = member.DeclaringType; while (parent != null) { sb.Append("class Stub {"); sb.Append(data.Editor.EolMarker); closingBrackets++; parent = parent.DeclaringType; } int memberStart = data.Editor.LocationToOffset(member.Location.Line, 1); int memberEnd = data.Editor.LocationToOffset(member.BodyRegion.End.Line + (runAferCR ? 1 : 0), member.BodyRegion.End.Column); if (memberEnd < 0) { memberEnd = data.Editor.Length; } int startOffset = sb.Length; sb.Append(data.Editor.GetTextBetween(memberStart, memberEnd)); int endOffset = sb.Length; sb.Append(data.Editor.EolMarker); sb.Append(new string ('}', closingBrackets)); TextEditorData stubData = new TextEditorData() { Text = sb.ToString() }; stubData.Document.FileName = data.FileName; var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser(); var compilationUnit = parser.Parse(stubData); bool hadErrors = parser.HasErrors; var policy = policyParent.Get <CSharpFormattingPolicy> (mimeTypeChain); var adapter = new TextEditorDataAdapter(stubData); var domSpacingVisitor = new AstFormattingVisitor(policy.CreateOptions(), adapter, new FormattingActionFactory(data.Editor)) { HadErrors = hadErrors }; compilationUnit.AcceptVisitor(domSpacingVisitor, null); var changes = new List <ICSharpCode.NRefactory.CSharp.Refactoring.Action> (); changes.AddRange(domSpacingVisitor.Changes.Cast <TextReplaceAction> ().Where(c => startOffset < c.Offset && c.Offset < endOffset)); int delta = memberStart - startOffset; HashSet <int> lines = new HashSet <int> (); foreach (TextReplaceAction change in changes) { change.Offset += delta; lines.Add(data.Editor.OffsetToLineNumber(change.Offset)); } // be sensible in documents with parser errors - only correct up to the caret position. if (hadErrors || data.ParsedDocument.Errors.Any(e => e.ErrorType == ErrorType.Error)) { var lastOffset = data.Editor.Caret.Offset; changes.RemoveAll(c => ((TextReplaceAction)c).Offset > lastOffset); } using (var undo = data.Editor.OpenUndoGroup()) { MDRefactoringContext.MdScript.RunActions(changes, null); foreach (int line in lines) { data.Editor.Document.CommitLineUpdate(line); } } stubData.Dispose(); }