public static string ReplaceStringLiteralsWithVariables(string text, IEnumerable<string> macros, Func<int, int, string, string, string> onReplace) { var setting = new CompilerSettings(); foreach (var macro in macros) setting.ConditionalSymbols.Add(macro); var tree = SyntaxTree.Parse(text, string.Empty, setting); tree.Freeze(); var doc = new StringBuilderDocument(text); using (var editor = new DocumentScript(doc, FormattingOptionsFactory.CreateAllman(), TextEditorOptions.Default)) { var originDoc = editor.OriginalDocument; foreach (var node in tree.Descendants.OfType<PrimitiveExpression>().Where(e => e.Value is string)) { var line = originDoc.GetLineByNumber(node.StartLocation.Line); var result = onReplace(node.StartLocation.Line, node.StartLocation.Column, originDoc.GetText(line), node.Value as string); if (result != null) { var names = result.Split('.'); Expression exp = new IdentifierExpression(names.First()); foreach (var name in names.Skip(1)) exp = exp.Member(name); editor.Replace(node, exp); } } } return doc.Text; }
public static OmniSharpRefactoringContext GetContext(BufferParser bufferParser, Request request) { var q = bufferParser.ParsedContent(request.Buffer, request.FileName); var resolver = new CSharpAstResolver(q.Compilation, q.SyntaxTree, q.UnresolvedFile); var doc = new StringBuilderDocument(request.Buffer); var location = new TextLocation(request.Line, request.Column); OmniSharpRefactoringContext refactoringContext; if(request is CodeActionRequest) { var car = request as CodeActionRequest; if(car.SelectionStartColumn.HasValue) { var startLocation = new TextLocation(car.SelectionStartLine.Value, car.SelectionStartColumn.Value); var endLocation = new TextLocation(car.SelectionEndLine.Value, car.SelectionEndColumn.Value); refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location, startLocation, endLocation); } else { refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location); } } else { refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location); } refactoringContext.Services.AddService (typeof(NamingConventionService), new DefaultNameService ()); return refactoringContext; }
static void Test (string input, string expectedOutput) { input = input.Replace("\r\n", "\n"); expectedOutput = expectedOutput.Replace("\r\n", "\n"); int caretPositon = input.IndexOf('$'); if (caretPositon > 0) input = input.Substring(0, caretPositon) + input.Substring(caretPositon + 1); var document1 = new StringBuilderDocument(input); int expectedCaretPosition = expectedOutput.IndexOf('$'); if (expectedCaretPosition > 0) expectedOutput = expectedOutput.Substring(0, expectedCaretPosition) + expectedOutput.Substring(expectedCaretPosition + 1); var fixer = new ConstructFixer(FormattingOptionsFactory.CreateMono (), new TextEditorOptions { EolMarker = "\n" }); int newCaretPosition; Assert.IsTrue(fixer.TryFix(document1, caretPositon, out newCaretPosition)); var isEqual = expectedOutput == document1.Text.Replace("\r\n", "\n"); if (!isEqual) { System.Console.WriteLine("expected:"); System.Console.WriteLine(expectedOutput); System.Console.WriteLine("was:"); System.Console.WriteLine(document1.Text); } Assert.IsTrue(isEqual); Assert.AreEqual(expectedCaretPosition, newCaretPosition); }
private OmniSharpRefactoringContext GetRefactoringContext(Request req) { var q = _bufferParser.ParsedContent(req.Buffer, req.FileName); var resolver = new CSharpAstResolver(q.Compilation, q.SyntaxTree, q.UnresolvedFile); var doc = new StringBuilderDocument(req.Buffer); var location = new TextLocation(req.Line, req.Column); var refactoringContext = new OmniSharpRefactoringContext(doc, location, resolver); return refactoringContext; }
public static OmniSharpRefactoringContext GetContext(BufferParser bufferParser, Request request) { var q = bufferParser.ParsedContent(request.Buffer, request.FileName); var resolver = new CSharpAstResolver(q.Compilation, q.SyntaxTree, q.UnresolvedFile); var doc = new StringBuilderDocument(request.Buffer); var location = new TextLocation(request.Line, request.Column); var refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location); return refactoringContext; }
//public static CSharpFormattingOptions tModLoaderFormat = FormattingOptionsFactory.CreateAllman(); public static string FormatCode(string text, CSharpFormattingOptions options, CancellationToken ct) { var formatter = new CSharpFormatter(options) { FormattingMode = FormattingMode.Intrusive }; text = text.Replace("\r\n\r\n", "\r\n"); var doc = new StringBuilderDocument(text); var syntaxTree = SyntaxTree.Parse(doc, doc.FileName, null, ct); formatter.AnalyzeFormatting(doc, syntaxTree, ct).ApplyChanges(); return doc.Text; }
public void Parse(IProject project, string fileName, string source) { this.FileName = fileName; this.Content = new StringTextSource(source); this.Document = new StringBuilderDocument(this.Content); this.Project = project; CSharpParser p = project.CreateParser(); this.SyntaxTree = p.Parse(Content.CreateReader(), fileName); this.ParsedFile = this.SyntaxTree.ToTypeSystem(); }
protected static FormattingChanges GetChanges(CSharpFormattingOptions policy, string input, out StringBuilderDocument document, FormattingMode mode = FormattingMode.Intrusive, TextEditorOptions options = null) { options = GetActualOptions(options); input = NormalizeNewlines(input); document = new StringBuilderDocument(input); var visitor = new CSharpFormatter(policy, options); visitor.FormattingMode = mode; var syntaxTree = new CSharpParser().Parse(document, "test.cs"); return visitor.AnalyzeFormatting(document, syntaxTree); }
/*public static string ApplyChanges (string text, List<TextReplaceAction> changes) { changes.Sort ((x, y) => y.Offset.CompareTo (x.Offset)); StringBuilder b = new StringBuilder(text); foreach (var change in changes) { //Console.WriteLine ("---- apply:" + change); // Console.WriteLine (adapter.Text); if (change.Offset > b.Length) continue; b.Remove(change.Offset, change.RemovedChars); b.Insert(change.Offset, change.InsertedText); } // Console.WriteLine ("---result:"); // Console.WriteLine (adapter.Text); return b.ToString(); }*/ protected static IDocument GetResult (CSharpFormattingOptions policy, string input, FormattingMode mode = FormattingMode.OnTheFly) { input = NormalizeNewlines (input); var document = new StringBuilderDocument (input); var options = new TextEditorOptions (); options.EolMarker = "\n"; var visitor = new AstFormattingVisitor (policy, document, options); visitor.FormattingMode = mode; var compilationUnit = new CSharpParser ().Parse (document, "test.cs"); compilationUnit.AcceptVisitor (visitor); visitor.ApplyChanges(); return document; }
/*public static string ApplyChanges (string text, List<TextReplaceAction> changes) { changes.Sort ((x, y) => y.Offset.CompareTo (x.Offset)); StringBuilder b = new StringBuilder(text); foreach (var change in changes) { //Console.WriteLine ("---- apply:" + change); // Console.WriteLine (adapter.Text); if (change.Offset > b.Length) continue; b.Remove(change.Offset, change.RemovedChars); b.Insert(change.Offset, change.InsertedText); } // Console.WriteLine ("---result:"); // Console.WriteLine (adapter.Text); return b.ToString(); }*/ protected static IDocument GetResult(CSharpFormattingOptions policy, string input, FormattingMode mode = FormattingMode.Intrusive) { input = NormalizeNewlines(input); var document = new StringBuilderDocument(input); var options = new TextEditorOptions(); options.EolMarker = "\n"; options.WrapLineLength = 80; var visitor = new CSharpFormatter (policy, options); visitor.FormattingMode = mode; var syntaxTree = new CSharpParser ().Parse (document, "test.cs"); var changes = visitor.AnalyzeFormatting(document, syntaxTree); changes.ApplyChanges(); return document; }
public CodeFormatResponse Format(CodeFormatRequest request) { var document = new StringBuilderDocument(request.Buffer); var options = new TextEditorOptions(); options.EolMarker = Environment.NewLine; options.WrapLineLength = 80; options.TabsToSpaces = request.ExpandTab; var policy = FormattingOptionsFactory.CreateAllman(); var visitor = new AstFormattingVisitor(policy, document, options); visitor.FormattingMode = FormattingMode.Intrusive; var syntaxTree = new CSharpParser().Parse(document, request.FileName); syntaxTree.AcceptVisitor(visitor); visitor.ApplyChanges(); return new CodeFormatResponse(document.Text); }
private static string RemoveMethods(string code, IEnumerable<MethodVisitorResult> methods) { var document = new StringBuilderDocument(code); using (var script = new DocumentScript( document, FormattingOptionsFactory.CreateAllman(), new TextEditorOptions())) { foreach (var method in methods) { var offset = script.GetCurrentOffset(method.MethodDefinition.GetRegion().Begin); script.Replace(method.MethodDefinition, new MethodDeclaration()); script.Replace(offset, new MethodDeclaration().GetText().Trim().Length, ""); } } return document.Text; }
private static string RemoveClasses(string code, IEnumerable<TypeDeclaration> classes) { var document = new StringBuilderDocument(code); using ( var script = new DocumentScript( document, FormattingOptionsFactory.CreateAllman(), new TextEditorOptions())) { foreach (var @class in classes) { var offset = script.GetCurrentOffset(@class.GetRegion().Begin); script.Replace(@class, new TypeDeclaration()); script.Replace(offset, new TypeDeclaration().GetText().Trim().Length, ""); } } return document.Text; }
public static void Main(string[] args) { if (args.Length != 4) { Console.WriteLine("use: RenameClass.exe <SolutionPath> <ClassNamespace> <CurrentClassName> <NewClassName>"); return; } var solutionFile = args[0]; // "C:\\Users\\v-ezeqs\\Documents\\Visual Studio 2010\\Projects\\Application36\\Application36.sln" var classNamespace = args[1]; // "Application36.WebHost" var className = args[2]; // "SiteMaster" var classNewName = args[3]; // "SiteMaster2" if (!File.Exists(solutionFile)) { Console.WriteLine("Solution not found at {0}", solutionFile); return; } Console.WriteLine("Loading solution..."); // Loading Solution in Memory Solution solution = new Solution(solutionFile); Console.WriteLine("Finding references..."); // Define which Type I'm looking for var typeReference = new GetClassTypeReference(classNamespace, className) as ITypeReference; // Try to find the Type definition in solution's projects foreach (var proj in solution.Projects) { var type = typeReference.Resolve(proj.Compilation); if (type.Kind != TypeKind.Unknown) { SetSearchedMembers(new List<object>() { type }); } } if (searchedMembers == null) { Console.WriteLine("Not References found. Refactoring Done."); return; } // Find all related members related with the Type (like Members, Methods, etc) ICSharpCode.NRefactory.CSharp.Resolver.FindReferences refFinder = new ICSharpCode.NRefactory.CSharp.Resolver.FindReferences(); var scopes = searchedMembers.Select (e => refFinder.GetSearchScopes (e as IEntity)); // Finding references to the Type on the one of the different Solution files refs = new List<dynamic>(); foreach (var file in solution.AllFiles.Distinct (new CSharpFileEqualityComparer())) { foreach (var scope in scopes) { refFinder.FindReferencesInFile( scope, file.UnresolvedTypeSystemForFile, file.SyntaxTree, file.Project.Compilation, (astNode, result) => { var newRef = GetReference(result, astNode, file); if (newRef == null || refs.Any(r => r.File.FileName == newRef.File.FileName && r.Region == newRef.Region)) return; refs.Add(newRef); }, CancellationToken.None ); } } Console.WriteLine("Refactoring {0} places in {1} files...", refs.Count(), refs.Select(x => x.File.FileName).Distinct().Count()); // Perform replace for each of the References found foreach (var r in refs) { // DocumentScript expects the the AST to stay unmodified (so that it fits // to the document state at the time of the DocumentScript constructor call), // so we call Freeze() to prevent accidental modifications (e.g. forgetting a Clone() call). r.File.SyntaxTree.Freeze(); // Create a document containing the file content: var fileText = File.ReadAllText(r.File.FileName); var document = new StringBuilderDocument(fileText); using (var script = new DocumentScript(document, FormattingOptionsFactory.CreateAllman(), new TextEditorOptions())) { // Alternative 1: clone a portion of the AST and modify it //var copy = (InvocationExpression)expr.Clone(); //copy.Arguments.Add(stringComparisonAst.Member("Ordinal")); //script.Replace(expr, copy); // Alternative 2: perform direct text insertion / replace int offset = script.GetCurrentOffset(r.Region.Begin); var length = r.Region.End.Column - r.Region.Begin.Column; script.Replace(offset, length, classNewName); } File.WriteAllText(r.File.FileName, document.Text); } Console.WriteLine("Refactoring Done."); }
public static TestRefactoringContext Create(string content, bool expectErrors = false) { int idx = content.IndexOf ("$"); if (idx >= 0) content = content.Substring (0, idx) + content.Substring (idx + 1); int idx1 = content.IndexOf ("<-"); int idx2 = content.IndexOf ("->"); int selectionStart = 0; int selectionEnd = 0; if (0 <= idx1 && idx1 < idx2) { content = content.Substring (0, idx2) + content.Substring (idx2 + 2); content = content.Substring (0, idx1) + content.Substring (idx1 + 2); selectionStart = idx1; selectionEnd = idx2 - 2; idx = selectionEnd; } var doc = new StringBuilderDocument(content); var parser = new CSharpParser(); var unit = parser.Parse(content, "program.cs"); if (!expectErrors) { if (parser.HasErrors) { Console.WriteLine (content); Console.WriteLine ("----"); } foreach (var error in parser.Errors) { Console.WriteLine(error.Message); } Assert.IsFalse(parser.HasErrors, "The file contains unexpected parsing errors."); } else { Assert.IsTrue(parser.HasErrors, "Expected parsing errors, but the file doesn't contain any."); } unit.Freeze (); var unresolvedFile = unit.ToTypeSystem (); IProjectContent pc = new CSharpProjectContent (); pc = pc.AddOrUpdateFiles (unresolvedFile); pc = pc.AddAssemblyReferences (new[] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore }); var compilation = pc.CreateCompilation (); var resolver = new CSharpAstResolver (compilation, unit, unresolvedFile); TextLocation location = TextLocation.Empty; if (idx >= 0) location = doc.GetLocation (idx); return new TestRefactoringContext(doc, location, resolver) { selectionStart = selectionStart, selectionEnd = selectionEnd }; }
public static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("Please specify the path to a .sln file on the command line"); Console.Write("Press any key to continue . . . "); Console.ReadKey(true); return; } Solution solution = new Solution(args[0]); foreach (var file in solution.AllFiles) { var astResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile); foreach (var invocation in file.SyntaxTree.Descendants.OfType<InvocationExpression>()) { // Retrieve semantics for the invocation var rr = astResolver.Resolve(invocation) as InvocationResolveResult; if (rr == null) { // Not an invocation resolve result - e.g. could be a UnknownMemberResolveResult instead continue; } if (rr.Member.FullName != "System.String.IndexOf") { // Invocation isn't a string.IndexOf call continue; } if (rr.Member.Parameters.First().Type.FullName != "System.String") { // Ignore the overload that accepts a char, as that doesn't take a StringComparison. // (looking for a char always performs the expected ordinal comparison) continue; } if (rr.Member.Parameters.Last().Type.FullName == "System.StringComparison") { // Already using the overload that specifies a StringComparison continue; } Console.WriteLine(invocation.GetRegion() + ": " + invocation.GetText()); file.IndexOfInvocations.Add(invocation); } } Console.WriteLine("Found {0} places to refactor in {1} files.", solution.AllFiles.Sum(f => f.IndexOfInvocations.Count), solution.AllFiles.Count(f => f.IndexOfInvocations.Count > 0)); Console.Write("Apply refactorings? "); string answer = Console.ReadLine(); if ("yes".Equals(answer, StringComparison.OrdinalIgnoreCase) || "y".Equals(answer, StringComparison.OrdinalIgnoreCase)) { foreach (var file in solution.AllFiles) { if (file.IndexOfInvocations.Count == 0) continue; // DocumentScript expects the the AST to stay unmodified (so that it fits // to the document state at the time of the DocumentScript constructor call), // so we call Freeze() to prevent accidental modifications (e.g. forgetting a Clone() call). file.SyntaxTree.Freeze(); // AST resolver used to find context for System.StringComparison generation var compilation = file.Project.Compilation; var astResolver = new CSharpAstResolver(compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile); // Create a document containing the file content: var document = new StringBuilderDocument(file.OriginalText); var formattingOptions = FormattingOptionsFactory.CreateAllman(); var options = new TextEditorOptions(); using (var script = new DocumentScript(document, formattingOptions, options)) { foreach (InvocationExpression expr in file.IndexOfInvocations) { // Generate a reference to System.StringComparison in this context: var astBuilder = new TypeSystemAstBuilder(astResolver.GetResolverStateBefore(expr)); IType stringComparison = compilation.FindType(typeof(StringComparison)); AstType stringComparisonAst = astBuilder.ConvertType(stringComparison); // Alternative 1: clone a portion of the AST and modify it var copy = (InvocationExpression)expr.Clone(); copy.Arguments.Add(stringComparisonAst.Member("Ordinal")); script.Replace(expr, copy); // // Alternative 2: perform direct text insertion // int offset = script.GetCurrentOffset(expr.RParToken.StartLocation); // script.InsertText(offset, ", " + stringComparisonAst.GetText() + ".Ordinal"); } } File.WriteAllText(Path.ChangeExtension(file.FileName, ".output.cs"), document.Text); } } }
public SimpleAnchor(StringBuilderDocument document, int offset) { this.document = document; this.offset = offset; }
public static TestRefactoringContext Create (string content) { int idx = content.IndexOf ("$"); if (idx >= 0) content = content.Substring (0, idx) + content.Substring (idx + 1); int idx1 = content.IndexOf ("<-"); int idx2 = content.IndexOf ("->"); int selectionStart = 0; int selectionEnd = 0; if (0 <= idx1 && idx1 < idx2) { content = content.Substring (0, idx2) + content.Substring (idx2 + 2); content = content.Substring (0, idx1) + content.Substring (idx1 + 2); selectionStart = idx1; selectionEnd = idx2 - 2; idx = selectionEnd; } var doc = new StringBuilderDocument (content); var parser = new CSharpParser (); var unit = parser.Parse (content, "program.cs"); if (parser.HasErrors) parser.ErrorPrinter.Errors.ForEach (e => Console.WriteLine (e.Message)); Assert.IsFalse (parser.HasErrors, "File contains parsing errors."); unit.Freeze (); var parsedFile = unit.ToTypeSystem (); IProjectContent pc = new CSharpProjectContent (); pc = pc.UpdateProjectContent (null, parsedFile); pc = pc.AddAssemblyReferences (new[] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore }); var compilation = pc.CreateCompilation (); var resolver = new CSharpAstResolver (compilation, unit, parsedFile); TextLocation location = TextLocation.Empty; if (idx >= 0) location = doc.GetLocation (idx); return new TestRefactoringContext(doc, location, resolver) { selectionStart = selectionStart, selectionEnd = selectionEnd }; }
private string GetMethodContentsFor(SyntaxTree syntaxTree, StringBuilderDocument document, string methodName, out bool wasFound) { ICSharpCode.NRefactory.CSharp.NamespaceDeclaration namespaceDecl = null; TypeDeclaration classDecl = null; MethodDeclaration methodDecl = null; BlockStatement blockStatement = null; string toReturn = null; ICSharpCode.NRefactory.TextLocation? start = null; ICSharpCode.NRefactory.TextLocation? end = null; foreach (var child in syntaxTree.Children) { if (child is ICSharpCode.NRefactory.CSharp.NamespaceDeclaration) { namespaceDecl = child as NamespaceDeclaration; break; } } if (namespaceDecl != null) { foreach (var child in namespaceDecl.Children) { if (child is TypeDeclaration) { classDecl = child as TypeDeclaration; break; } } } if (classDecl != null) { foreach (var child in classDecl.Children) { if (child is MethodDeclaration && (child as MethodDeclaration).Name == "On" + methodName) { methodDecl = child as MethodDeclaration; break; } } } if (methodDecl != null) { foreach (var child in methodDecl.Children) { if (child is BlockStatement) { blockStatement = child as BlockStatement; break; } } } if (blockStatement != null) { foreach (var child in blockStatement.Children) { if ((child is CSharpTokenNode) == false) { if (start == null) { start = child.StartLocation; } end = child.EndLocation; } } } if (start.HasValue) { int offset = document.GetOffset(start.Value); int length = document.GetOffset(end.Value) - offset; wasFound = true; return document.GetText(offset, length); } else if (blockStatement != null) { // we found a pure empty method wasFound = true; return ""; } else { wasFound = false; return null; } }
public void UpdateDisplayToCurrentObject() { string fullFileName = "<Unable to get file name>"; try { EventResponseSave eventResponseSave = EditorLogic.CurrentEventResponseSave; IElement element = EditorLogic.CurrentElement; fullFileName = eventResponseSave.GetSharedCodeFullFileName(); string contents = FileManager.FromFileText(fullFileName); CSharpParser parser = new CSharpParser(); SyntaxTree syntaxTree = parser.Parse(contents); mIsCodeValid = syntaxTree.Errors.Count == 0; if (mIsCodeValid) { ParsedMethod parsedMethod = eventResponseSave.GetParsedMethodFromAssociatedFile(); string textToAssign = null; if (parsedMethod == null) { textToAssign = eventResponseSave.GetEventContents(); } else { StringBuilderDocument document = new StringBuilderDocument(contents); bool wasFound; textToAssign = GetMethodContentsFor(syntaxTree, document, eventResponseSave.EventName, out wasFound); if (wasFound) { textToAssign = textToAssign.Replace("\n", "\r\n"); } else { mIsCodeValid = false; textToAssign = "Could not find the method, or encountered a parse error."; } } textToAssign = RemoveWhiteSpaceForCodeWindow(textToAssign); this.syntaxBoxControl1.Document.Text = textToAssign; mLastSavedText = this.syntaxBoxControl1.Document.Text; } else { this.syntaxBoxControl1.Document.Text = "This code file is not a complete code file:\n" + fullFileName + "\nGlue is unable to parse it. Please correct the problems in Visual Studio"; } } catch (Exception e) { mIsCodeValid = false; this.syntaxBoxControl1.Document.Text = "Error parsing file:\n" + fullFileName + "\nMore details:\n\n" + e.ToString(); } }
public static TestRefactoringContext Create (List<string> contents, int mainIndex, bool expectErrors = false, CSharpParser parser = null) { List<int> indexes = new List<int>(); List<int> selectionStarts = new List<int>(); List<int> selectionEnds = new List<int>(); List<IDocument> documents = new List<IDocument>(); List<CSharpUnresolvedFile> unresolvedFiles = new List<CSharpUnresolvedFile>(); List<SyntaxTree> units = new List<SyntaxTree>(); for (int i = 0; i < contents.Count; i++) { string content = contents[i]; int idx = content.IndexOf("$"); if (idx >= 0) content = content.Substring(0, idx) + content.Substring(idx + 1); int idx1 = content.IndexOf("<-"); int idx2 = content.IndexOf("->"); int selectionStart = 0; int selectionEnd = 0; if (0 <= idx1 && idx1 < idx2) { content = content.Substring(0, idx2) + content.Substring(idx2 + 2); content = content.Substring(0, idx1) + content.Substring(idx1 + 2); selectionStart = idx1; selectionEnd = idx2 - 2; idx = selectionEnd; } indexes.Add(idx); selectionStarts.Add(selectionStart); selectionEnds.Add(selectionEnd); var doc = new StringBuilderDocument(content); if (parser == null) parser = new CSharpParser(); var unit = parser.Parse(content, "program_" + i + ".cs"); if (!expectErrors) { if (parser.HasErrors) { Console.WriteLine(content); Console.WriteLine("----"); } foreach (var error in parser.ErrorsAndWarnings) { Console.WriteLine(error.Message); } Assert.IsFalse(parser.HasErrors, "The file " + i + " contains unexpected parsing errors."); } else { Assert.IsTrue(parser.HasErrors, "Expected parsing errors, but the file " + i + "doesn't contain any."); } unit.Freeze(); CSharpUnresolvedFile unresolvedFile = unit.ToTypeSystem(); units.Add(unit); documents.Add(doc); unresolvedFiles.Add(unresolvedFile); } IProjectContent pc = new CSharpProjectContent (); pc = pc.AddOrUpdateFiles (unresolvedFiles); pc = pc.AddAssemblyReferences (new[] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore }); var compilation = pc.CreateCompilation (); List<TestRefactoringContext> contexts = new List<TestRefactoringContext>(); for (int documentIndex = 0; documentIndex < documents.Count; ++documentIndex) { var doc = documents [documentIndex]; var resolver = new CSharpAstResolver (compilation, units[documentIndex], unresolvedFiles[documentIndex]); TextLocation location = TextLocation.Empty; if (indexes[documentIndex] >= 0) location = doc.GetLocation (indexes[documentIndex]); var context = new TestRefactoringContext(doc, location, resolver) { selectionStart = selectionStarts[documentIndex], selectionEnd = selectionEnds[documentIndex], projectContexts = contexts, version = parser.CompilerSettings.LanguageVersion, defaultNamespace = "Test" }; contexts.Add(context); } return contexts [mainIndex]; }