private static void AssertChangedTextLinesHelper(string originalText, params TextChange[] changes) { var changedText = SourceText.From(originalText).WithChanges(changes); Assert.Equal(SourceText.From(changedText.ToString()).Lines, changedText.Lines, new TextLineEqualityComparer()); }
public async Task TestUpdatedDocumentHasTextVersionAsync() { var pid = ProjectId.CreateNewId(); var text = SourceText.From("public class C { }"); var version = VersionStamp.Create(); var docInfo = DocumentInfo.Create(DocumentId.CreateNewId(pid), "c.cs", loader: TextLoader.From(TextAndVersion.Create(text, version))); var projInfo = ProjectInfo.Create( pid, version: VersionStamp.Default, name: "TestProject", assemblyName: "TestProject.dll", language: LanguageNames.CSharp, documents: new[] { docInfo }); using var ws = new AdhocWorkspace(); ws.AddProject(projInfo); var doc = ws.CurrentSolution.GetDocument(docInfo.Id); Assert.False(doc.TryGetText(out var currentText)); Assert.False(doc.TryGetTextVersion(out var currentVersion)); // cause text to load and show that TryGet now works for text and version currentText = await doc.GetTextAsync(); Assert.True(doc.TryGetText(out currentText)); Assert.True(doc.TryGetTextVersion(out currentVersion)); Assert.Equal(version, currentVersion); // change document var root = await doc.GetSyntaxRootAsync(); var newRoot = root.WithAdditionalAnnotations(new SyntaxAnnotation()); Assert.NotSame(root, newRoot); var newDoc = doc.WithSyntaxRoot(newRoot); Assert.NotSame(doc, newDoc); // text is now unavailable since it must be constructed from tree Assert.False(newDoc.TryGetText(out currentText)); // version is available because it is cached Assert.True(newDoc.TryGetTextVersion(out currentVersion)); // access it the hard way var actualVersion = await newDoc.GetTextVersionAsync(); // version is the same Assert.Equal(currentVersion, actualVersion); // accessing text version did not cause text to be constructed. Assert.False(newDoc.TryGetText(out currentText)); // now access text directly (force it to be constructed) var actualText = await newDoc.GetTextAsync(); actualVersion = await newDoc.GetTextVersionAsync(); // prove constructing text did not introduce a new version Assert.Equal(currentVersion, actualVersion); }
private static int Wain(string[] args) { var app = new CommandLineApplication(throwOnUnexpectedArg: false) { ExtendedHelpText = "Starting without a path to a CSX file or a command, starts the REPL (interactive) mode." }; var file = app.Argument("script", "Path to CSX script"); var interactive = app.Option("-i | --interactive", "Execute a script and drop into the interactive mode afterwards.", CommandOptionType.NoValue); var configuration = app.Option("-c | --configuration <configuration>", "Configuration to use for running the script [Release/Debug] Default is \"Debug\"", CommandOptionType.SingleValue); var packageSources = app.Option("-s | --sources <SOURCE>", "Specifies a NuGet package source to use when resolving NuGet packages.", CommandOptionType.MultipleValue); var debugMode = app.Option(DebugFlagShort + " | " + DebugFlagLong, "Enables debug output.", CommandOptionType.NoValue); var verbosity = app.Option("--verbosity", " Set the verbosity level of the command. Allowed values are t[trace], d[ebug], i[nfo], w[arning], e[rror], and c[ritical].", CommandOptionType.SingleValue); var nocache = app.Option("--nocache", "disable DLL caching", CommandOptionType.NoValue); var argsBeforeDoubleHyphen = args.TakeWhile(a => a != "--").ToArray(); var argsAfterDoubleHypen = args.SkipWhile(a => a != "--").Skip(1).ToArray(); app.HelpOption("-? | -h | --help"); app.VersionOption("-v | --version", GetVersion); var infoOption = app.Option("--info", "Displays environmental information", CommandOptionType.NoValue); app.Command("eval", c => { c.Description = "Execute CSX code."; var code = c.Argument("code", "Code to execute."); var cwd = c.Option("-cwd |--workingdirectory <currentworkingdirectory>", "Working directory for the code compiler. Defaults to current directory.", CommandOptionType.SingleValue); c.OnExecute(async() => { int exitCode = 0; if (!string.IsNullOrWhiteSpace(code.Value)) { var optimizationLevel = OptimizationLevel.Debug; if (configuration.HasValue() && configuration.Value().ToLower() == "release") { optimizationLevel = OptimizationLevel.Release; } var logFactory = CreateLogFactory(verbosity.Value(), debugMode.HasValue()); exitCode = await RunCode(code.Value, debugMode.HasValue(), logFactory, optimizationLevel, app.RemainingArguments.Concat(argsAfterDoubleHypen), cwd.Value(), packageSources.Values?.ToArray()); } return(exitCode); }); }); app.Command("init", c => { c.Description = "Creates a sample script along with the launch.json file needed to launch and debug the script."; var fileName = c.Argument("filename", "(Optional) The name of the sample script file to be created during initialization. Defaults to 'main.csx'"); var cwd = c.Option("-cwd |--workingdirectory <currentworkingdirectory>", "Working directory for initialization. Defaults to current directory.", CommandOptionType.SingleValue); c.OnExecute(() => { var logFactory = CreateLogFactory(verbosity.Value(), debugMode.HasValue()); var scaffolder = new Scaffolder(logFactory); scaffolder.InitializerFolder(fileName.Value, cwd.Value() ?? Directory.GetCurrentDirectory()); return(0); }); }); app.Command("new", c => { c.Description = "Creates a new script file"; var fileNameArgument = c.Argument("filename", "The script file name"); var cwd = c.Option("-cwd |--workingdirectory <currentworkingdirectory>", "Working directory the new script file to be created. Defaults to current directory.", CommandOptionType.SingleValue); c.OnExecute(() => { var logFactory = CreateLogFactory(verbosity.Value(), debugMode.HasValue()); var scaffolder = new Scaffolder(logFactory); if (fileNameArgument.Value == null) { c.ShowHelp(); return(0); } scaffolder.CreateNewScriptFile(fileNameArgument.Value, cwd.Value() ?? Directory.GetCurrentDirectory()); return(0); }); }); app.Command("publish", c => { c.Description = "Creates a self contained executable or DLL from a script"; var fileNameArgument = c.Argument("filename", "The script file name"); var publishDirectoryOption = c.Option("-o |--output", "Directory where the published executable should be placed. Defaults to a 'publish' folder in the current directory.", CommandOptionType.SingleValue); var dllName = c.Option("-n |--name", "The name for the generated DLL (executable not supported at this time). Defaults to the name of the script.", CommandOptionType.SingleValue); var dllOption = c.Option("--dll", "Publish to a .dll instead of an executable.", CommandOptionType.NoValue); var commandConfig = c.Option("-c | --configuration <configuration>", "Configuration to use for publishing the script [Release/Debug]. Default is \"Debug\"", CommandOptionType.SingleValue); var publishDebugMode = c.Option(DebugFlagShort + " | " + DebugFlagLong, "Enables debug output.", CommandOptionType.NoValue); var runtime = c.Option("-r |--runtime", "The runtime used when publishing the self contained executable. Defaults to your current runtime.", CommandOptionType.SingleValue); c.OnExecute(() => { if (fileNameArgument.Value == null) { c.ShowHelp(); return(0); } var optimizationLevel = OptimizationLevel.Debug; if (commandConfig.HasValue() && commandConfig.Value().ToLower() == "release") { optimizationLevel = OptimizationLevel.Release; } var runtimeIdentifier = runtime.Value() ?? ScriptEnvironment.Default.RuntimeIdentifier; var absoluteFilePath = Path.IsPathRooted(fileNameArgument.Value) ? fileNameArgument.Value : Path.Combine(Directory.GetCurrentDirectory(), fileNameArgument.Value); // if a publish directory has been specified, then it is used directly, otherwise: // -- for EXE {current dir}/publish/{runtime ID} // -- for DLL {current dir}/publish var publishDirectory = publishDirectoryOption.Value() ?? (dllOption.HasValue() ? Path.Combine(Path.GetDirectoryName(absoluteFilePath), "publish") : Path.Combine(Path.GetDirectoryName(absoluteFilePath), "publish", runtimeIdentifier)); var absolutePublishDirectory = Path.IsPathRooted(publishDirectory) ? publishDirectory : Path.Combine(Directory.GetCurrentDirectory(), publishDirectory); var logFactory = CreateLogFactory(verbosity.Value(), debugMode.HasValue()); var compiler = GetScriptCompiler(publishDebugMode.HasValue(), logFactory); var scriptEmmiter = new ScriptEmitter(ScriptConsole.Default, compiler); var publisher = new ScriptPublisher(logFactory, scriptEmmiter); var code = SourceText.From(File.ReadAllText(absoluteFilePath)); var context = new ScriptContext(code, absolutePublishDirectory, Enumerable.Empty <string>(), absoluteFilePath, optimizationLevel); if (dllOption.HasValue()) { publisher.CreateAssembly <int, CommandLineScriptGlobals>(context, logFactory, dllName.Value()); } else { publisher.CreateExecutable <int, CommandLineScriptGlobals>(context, logFactory, runtimeIdentifier); } return(0); }); }); app.Command("exec", c => { c.Description = "Run a script from a DLL."; var dllPath = c.Argument("dll", "Path to DLL based script"); var commandDebugMode = c.Option(DebugFlagShort + " | " + DebugFlagLong, "Enables debug output.", CommandOptionType.NoValue); c.OnExecute(async() => { int exitCode = 0; if (!string.IsNullOrWhiteSpace(dllPath.Value)) { if (!File.Exists(dllPath.Value)) { throw new Exception($"Couldn't find file '{dllPath.Value}'"); } var logFactory = CreateLogFactory(verbosity.Value(), debugMode.HasValue()); var absoluteFilePath = Path.IsPathRooted(dllPath.Value) ? dllPath.Value : Path.Combine(Directory.GetCurrentDirectory(), dllPath.Value); var compiler = GetScriptCompiler(commandDebugMode.HasValue(), logFactory); var runner = new ScriptRunner(compiler, logFactory, ScriptConsole.Default); var result = await runner.Execute <int>(absoluteFilePath, app.RemainingArguments.Concat(argsAfterDoubleHypen)); return(result); } return(exitCode); }); }); app.OnExecute(async() => { int exitCode = 0; if (infoOption.HasValue()) { Console.Write(GetEnvironmentInfo()); return(0); } var logFactory = CreateLogFactory(verbosity.Value(), debugMode.HasValue()); if (!string.IsNullOrWhiteSpace(file.Value)) { if (Debugger.IsAttached || nocache.HasValue()) { var optimizationLevel = OptimizationLevel.Debug; if (configuration.HasValue() && configuration.Value().ToLower() == "release") { optimizationLevel = OptimizationLevel.Release; } exitCode = await RunScript(file.Value, debugMode.HasValue(), logFactory, optimizationLevel, app.RemainingArguments.Concat(argsAfterDoubleHypen), interactive.HasValue(), packageSources.Values?.ToArray()); } else { string cacheFolder = Path.Combine(Path.GetTempPath(), "dotnet-scripts"); // create unique folder name based on the path string uniqueFolderName = ""; using (var sha = SHA256.Create()) { uniqueFolderName = Convert.ToBase64String(sha.ComputeHash(Encoding.Unicode.GetBytes(file.Value))).Replace("=", String.Empty).Replace("/", string.Empty); } string publishDirectory = Path.Combine(cacheFolder, uniqueFolderName); if (!Directory.Exists(publishDirectory)) { Directory.CreateDirectory(publishDirectory); } string absoluteSourcePath; SourceText code; if (!File.Exists(file.Value)) { if (IsHttpUri(file.Value)) { var downloader = new ScriptDownloader(); var rawCode = await downloader.Download(file.Value); absoluteSourcePath = Path.Combine(publishDirectory, "source.csx"); File.WriteAllText(absoluteSourcePath, rawCode); code = SourceText.From(rawCode); } else { throw new Exception($"Couldn't find file '{file}'"); } } else { absoluteSourcePath = Path.IsPathRooted(file.Value) ? Path.GetFullPath(file.Value) : Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), file.Value)); code = SourceText.From(File.ReadAllText(absoluteSourcePath)); } // given the path to a script we create a %temp%\dotnet-scripts\{uniqueFolderName} path string pathToDll = Path.Combine(publishDirectory, Path.GetFileNameWithoutExtension(absoluteSourcePath) + ".dll"); // source hash is the checkSum of the code string sourceHash = Convert.ToBase64String(code.GetChecksum().ToArray()); // get hash code from previous run string hashCache = Path.Combine(publishDirectory, ".hash"); var compiler = GetScriptCompiler(true, logFactory); // if we don't have hash if (!File.Exists(hashCache) || // or we haven't created a dll !Directory.Exists(publishDirectory) || // the hashcode has changed (meaning new content) File.ReadAllText(hashCache) != sourceHash) { // then we autopublish into the %temp%\dotnet-scripts\{uniqueFolderName} path var optimizationLevel = OptimizationLevel.Debug; if (configuration.HasValue() && configuration.Value().ToLower() == "release") { optimizationLevel = OptimizationLevel.Release; } var runtimeIdentifier = ScriptEnvironment.Default.RuntimeIdentifier; var scriptEmmiter = new ScriptEmitter(ScriptConsole.Default, compiler); var publisher = new ScriptPublisher(logFactory, scriptEmmiter); var context = new ScriptContext(code, publishDirectory, Enumerable.Empty <string>(), absoluteSourcePath, optimizationLevel); // create the assembly in our cache folder publisher.CreateAssembly <int, CommandLineScriptGlobals>(context, logFactory, Path.GetFileNameWithoutExtension(pathToDll)); // save sourceHash for next time, so we can know it's ok to use the generated dll next time File.WriteAllText(hashCache, sourceHash); } // run the cached %temp%\dotnet-scripts\{uniqueFolderName}/package.dll var runner = new ScriptRunner(compiler, logFactory, ScriptConsole.Default); var result = await runner.Execute <int>(pathToDll, app.RemainingArguments.Concat(argsAfterDoubleHypen)); return(result); } } else { await RunInteractive(debugMode.HasValue(), logFactory, packageSources.Values?.ToArray()); } return(exitCode); }); return(app.Execute(argsBeforeDoubleHyphen)); }
public async Task Project_AnalyzerOptions_Change() { using (var workspace = new WorkCoordinatorWorkspace(SolutionCrawler)) { var solutionInfo = GetInitialSolutionInfo(workspace); workspace.OnSolutionAdded(solutionInfo); await WaitWaiterAsync(workspace.ExportProvider); var project = workspace.CurrentSolution.Projects.First(p => p.Name == "P1").AddAdditionalDocument("a1", SourceText.From("")).Project; var worker = await ExecuteOperation(workspace, w => w.ChangeProject(project.Id, project.Solution)); Assert.Equal(5, worker.SyntaxDocumentIds.Count); Assert.Equal(5, worker.DocumentIds.Count); } }
public async Task Document_AdditionalFileChange() { using (var workspace = new WorkCoordinatorWorkspace(SolutionCrawler)) { var solution = GetInitialSolutionInfo(workspace); workspace.OnSolutionAdded(solution); await WaitWaiterAsync(workspace.ExportProvider); var project = solution.Projects[0]; var ncfile = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), "D6"); var worker = await ExecuteOperation(workspace, w => w.OnAdditionalDocumentAdded(ncfile)); Assert.Equal(5, worker.SyntaxDocumentIds.Count); Assert.Equal(5, worker.DocumentIds.Count); worker = await ExecuteOperation(workspace, w => w.ChangeAdditionalDocument(ncfile.Id, SourceText.From("//"))); Assert.Equal(5, worker.SyntaxDocumentIds.Count); Assert.Equal(5, worker.DocumentIds.Count); worker = await ExecuteOperation(workspace, w => w.OnAdditionalDocumentRemoved(ncfile.Id)); Assert.Equal(5, worker.SyntaxDocumentIds.Count); Assert.Equal(5, worker.DocumentIds.Count); } }
public static StatementSyntax ParseStatement(string text) { return((StatementSyntax)Parse(SourceText.From(text), null, null, p => p.ParseStatement()).Root); }
private void GenerateCode(GeneratorExecutionContext context, TypeDeclarationSyntax tds, Type attributeType) { // Field symbol var symbol = context.ParseSyntaxNode <INamedTypeSymbol>(tds); if (symbol == null || context.CancellationToken.IsCancellationRequested) { return; } // Attribute data var attributeData = symbol.GetAttributeData(attributeType.FullName); // Snake case var snakeCase = attributeData?.GetValue <bool>(nameof(AutoToParametersAttribute.SnakeCase)); // Name space and class name var(ns, className) = (symbol.ContainingNamespace.ToDisplayString(), symbol.Name); // Keyword var keyword = tds.Keyword.ToString(); // Is Public var isPublic = tds.HasToken(SyntaxKind.PublicKeyword); // Name var name = tds.Identifier.ToString(); // Inheritance var externals = new List <string>(); // Body var body = GenerateBody(context, tds, snakeCase.GetValueOrDefault(), externals, ns); if (context.CancellationToken.IsCancellationRequested) { return; } externals.Add($"com.etsoo.Utils.Serialization.IDictionaryParser<{name}>"); // Source code var source = $@"#nullable enable using com.etsoo.Utils.String; using System; using System.Collections.Generic; using System.Linq; namespace {ns} {{ {(isPublic ? "public" : "internal")} partial {keyword} {className} : {string.Join(", ", externals)} {{ public static {name} Create(StringKeyDictionaryObject dic) {{ return new {name} {body}; }} }} }} "; context.AddSource($"{ns}.{className}.Dictionary.Generated.cs", SourceText.From(source, Encoding.UTF8)); }
public void Execute(GeneratorExecutionContext context) { var fields = GetAircraftFields(context).ToList(); var builder = new StringBuilder(); builder.Append(@" using System; using Microsoft.Extensions.Logging; using Microsoft.FlightSimulator.SimConnect; namespace FlightRecorder.Client.SimConnectMSFS { public partial class Connector {"); builder.Append(@" private void RegisterAircraftPositionDefinition() { RegisterDataDefinition<AircraftPositionStruct>(DEFINITIONS.AircraftPosition"); foreach ((_, _, var variable, var unit, var type, _, _) in fields) { builder.Append($@", (""{variable}"", ""{unit}"", (SIMCONNECT_DATATYPE){type})"); } builder.Append(@" ); } "); builder.Append(@" private void RegisterAircraftPositionSetDefinition() { RegisterDataDefinition<AircraftPositionSetStruct>(DEFINITIONS.AircraftPositionSet"); foreach ((_, _, var variable, var unit, var type, var setType, _) in fields) { if (setType == null || setType == SetTypeDefault) { builder.Append($@", (""{variable}"", ""{unit}"", (SIMCONNECT_DATATYPE){type})"); } } builder.Append(@" ); } "); builder.Append(@" private void RegisterEvents() {"); var eventId = InitialEventID; foreach ((_, _, var variable, var unit, var type, var setType, var setBy) in fields) { if (setType == SetTypeEvent) { // TODO: warning if setBy is empty builder.Append($@" logger.LogDebug(""Register event {{eventName}} to ID {{eventID}}"", ""{setBy}"", {eventId}); simconnect.MapClientEventToSimEvent((EVENTS){eventId}, ""{setBy}"");"); eventId++; } } builder.Append(@" } "); builder.Append(@" public void TriggerEvents(AircraftPositionStruct current, AircraftPositionStruct expected) {"); eventId = InitialEventID; foreach ((_, var name, var variable, var unit, var type, var setType, var setBy) in fields) { if (setType == SetTypeEvent) { // TODO: warning if setBy is empty builder.Append($@" if (current.{name} != expected.{name}) {{ logger.LogDebug(""Trigger event {{eventName}}"", ""{setBy}""); simconnect.TransmitClientEvent(SimConnect.SIMCONNECT_OBJECT_ID_USER, (EVENTS){eventId}, 0, GROUPS.GENERIC, SIMCONNECT_EVENT_FLAG.GROUPID_IS_PRIORITY); }} "); eventId++; } } builder.Append(@" } "); builder.Append(@" } }"); context.AddSource("ConnectorGenerator", SourceText.From(builder.ToString(), Encoding.UTF8)); }
private TextLine GetLine(string codeLine) { var text = SourceText.From(codeLine); return(text.Lines[0]); }
public override SourceText GetText(CancellationToken cancellationToken) { return(SourceText.From(string.Empty, Encoding.UTF8)); }
public override bool TryGetText(out SourceText text) { text = SourceText.From(string.Empty, Encoding.UTF8); return(true); }
public void UpdateText(DocumentId documentId, string text) { OnDocumentTextChanged(documentId, SourceText.From(text, Encoding.UTF8), PreservationMode.PreserveValue); }
public DocumentId AddProjectWithDocument(string documentFileName, string text) { var fileName = Path.GetFileName(documentFileName); var name = Path.GetFileNameWithoutExtension(documentFileName); var language = Path.GetExtension(documentFileName) == ".vb" ? LanguageNames.VisualBasic : LanguageNames.CSharp; var projectId = ProjectId.CreateNewId(); // ValueTuple needs a separate assembly in .NET 4.6.x. But it is not needed anymore in .NET 4.7+ as it is included in mscorelib. var references = defaultReferences.Distinct().Select(CreateReference).ToList(); references.Add(CreateReference(Assembly.Load("System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"))); if (language == LanguageNames.VisualBasic) { references.Add(CreateReference(typeof(VBMath).Assembly)); } else if (language == LanguageNames.CSharp) { references.Add(CreateReference(typeof(RuntimeBinderException).Assembly)); } var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Default, name, name + ".dll", language, metadataReferences: references, parseOptions: language == LanguageNames.CSharp ? (ParseOptions) new CSharpParseOptions(languageVersion: Microsoft.CodeAnalysis.CSharp.LanguageVersion.Latest) : new VisualBasicParseOptions(Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.Latest)); OnProjectAdded(projectInfo); var documentId = DocumentId.CreateNewId(projectId); var documentInfo = DocumentInfo.Create(documentId, fileName, loader: TextLoader.From(TextAndVersion.Create(SourceText.From(text, Encoding.UTF8), VersionStamp.Create()))); OnDocumentAdded(documentInfo); return(documentId); }
private Task <Project> CreateProject() { var fileNamePrefix = "Test"; var fileExt = ".cs"; var testProjectName = "TestProject"; var projectId = ProjectId.CreateNewId(debugName: testProjectName); switch (TargetFramework) { case TargetFramework.NetStandard2_0: AddNuGetReference("NETStandard.Library", "2.0.3", "build/netstandard2.0/ref/"); break; case TargetFramework.NetStandard2_1: AddNuGetReference("NETStandard.Library.Ref", "2.1.0", "ref/netstandard2.1/"); break; case TargetFramework.Net48: AddNuGetReference("Microsoft.NETFramework.ReferenceAssemblies.net48", "1.0.0", "build/.NETFramework/v4.8/"); break; case TargetFramework.Net50: AddNuGetReference("Microsoft.NETCore.App.Ref", "5.0.0", "ref/net5.0/"); break; case TargetFramework.AspNetCore50: AddNuGetReference("Microsoft.NETCore.App.Ref", "5.0.0", "ref/net5.0/"); AddNuGetReference("Microsoft.AspNetCore.App.Ref", "5.0.0", "ref/net5.0/"); break; case TargetFramework.WindowsDesktop50: AddNuGetReference("Microsoft.WindowsDesktop.App.Ref", "5.0.0", "ref/net5.0/"); break; } AddNuGetReference("System.Collections.Immutable", "1.5.0", "lib/netstandard2.0/"); AddNuGetReference("System.Numerics.Vectors", "4.5.0", "ref/netstandard2.0/"); AddNuGetReference("Microsoft.CSharp", "4.7.0", "lib/netstandard2.0/"); // To support dynamic type var solution = new AdhocWorkspace() .CurrentSolution .AddProject(projectId, testProjectName, testProjectName, LanguageNames.CSharp) .WithProjectParseOptions(projectId, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion)) .AddMetadataReferences(projectId, References); var count = 0; AppendFile(FileName, SourceCode); foreach (var source in ApiReferences) { var newFileName = fileNamePrefix + count + fileExt; AppendFile(newFileName, source); } return(Task.FromResult(solution.GetProject(projectId))); void AppendFile(string filename, string content) { filename ??= fileNamePrefix + count + fileExt; var documentId = DocumentId.CreateNewId(projectId, debugName: filename); solution = solution.AddDocument(documentId, filename, SourceText.From(content), filePath: filename); count++; } }
public static AnalyzerConfig Parse(string text, string pathToFile) { return(Parse(SourceText.From(text), pathToFile)); }
internal CompletionList CreateProvider(string input, SourceCodeKind?sourceCodeKind = null, bool usePreviousCharAsTrigger = false) { int cursorPosition = input.IndexOf("$$", StringComparison.Ordinal); var parsedText = input.Substring(0, cursorPosition) + input.Substring(cursorPosition + 2); var workspace = new InspectionActionTestBase.TestWorkspace(); var projectId = ProjectId.CreateNewId(); //var solutionId = SolutionId.CreateNewId(); var documentId = DocumentId.CreateNewId(projectId); workspace.Open(ProjectInfo.Create( projectId, VersionStamp.Create(), "TestProject", "TestProject", LanguageNames.CSharp, null, null, new CSharpCompilationOptions( OutputKind.DynamicallyLinkedLibrary, false, "", "", "Script", null, OptimizationLevel.Debug, false, false ), new CSharpParseOptions( LanguageVersion.CSharp6, DocumentationMode.None, SourceCodeKind.Regular, ImmutableArray.Create("DEBUG", "TEST") ), new [] { DocumentInfo.Create( documentId, "a.cs", null, SourceCodeKind.Regular, TextLoader.From(TextAndVersion.Create(SourceText.From(parsedText), VersionStamp.Create())) ) }, null, InspectionActionTestBase.DefaultMetadataReferences ) ); var engine = new MonoDevelop.CSharp.Completion.RoslynParameterHintingEngine(); var compilation = workspace.CurrentSolution.GetProject(projectId).GetCompilationAsync().Result; var document = workspace.CurrentSolution.GetDocument(documentId); var semanticModel = document.GetSemanticModelAsync().Result; char triggerChar = cursorPosition > 0 ? document.GetTextAsync().Result [cursorPosition - 1] : '\0'; var cs = (CSharpCompletionService)workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService <CompletionService> (); cs.SetTestProviders(CreateCompletionProvider()); var trigger = CompletionTrigger.Invoke; if (usePreviousCharAsTrigger) { trigger = new CompletionTrigger(CompletionTriggerKind.Insertion, triggerChar); } return(cs.GetCompletionsAsync(document, cursorPosition, trigger, null, null, default(CancellationToken)).Result); }
public static SyntaxTree ParseExpression(string text) { return(Parse(SourceText.From(text), null, null, p => p.ParseExpression())); }
public AdditionalTextFile(string path) { Path = path; _text = SourceText.From(File.ReadAllText(path)); }
public static SyntaxToken ParseToken(string text) { return(new HlslLexer(new SourceFile(SourceText.From(text), null)).Lex(LexerMode.Syntax)); }
public AdditionalTextHelper(string path, string text) { this.Path = path; this.sourceText = SourceText.From(text); }
private static void Processor(Options o) { try { var results = new Dictionary <string, List <Result> >(); if (string.IsNullOrEmpty(o.CsvOutput)) { DateTime dt = DateTime.Now; string timestamp = dt.ToString("yyyyMMddHHmmss"); o.CsvOutput = "enumerated_controllers_" + timestamp + ".csv"; } //var documents = LoadSolution(o.SolutionPath); string[] paths = Directory.GetFiles(o.Directory, "*.cs", SearchOption.AllDirectories); if (paths.Any()) { foreach (var path in paths) { using (var stream = File.OpenRead(path)) { var tree = CSharpSyntaxTree.ParseText(SourceText.From(stream), path: path); SyntaxNode root = tree.GetRoot(); // Check if the Class inherits Apicontroller or Controller and print out all the public entry points ControllerChecker controllerchk = new ControllerChecker(); if (controllerchk.inheritsFromController(root, o.AttributeSearch)) { controllerchk.enumerateEntrypoints(root, o.AttributeSearch, o.NegativeSearch, path, results); } } } string[] controllerPaths = results.Keys.ToArray(); string pathToTrim = getPathToTrim(controllerPaths); if (!string.IsNullOrEmpty(o.AttributeSearch) || !string.IsNullOrEmpty(o.NegativeSearch)) { printCommandLineResults(results, pathToTrim); } printCSVResults(results, o.CsvOutput, pathToTrim); } else { Console.WriteLine("Unable to find any document from solution line"); } } catch (DirectoryNotFoundException) { Console.WriteLine("Invalid Path"); } catch (IndexOutOfRangeException) { //Shoudn't Reach this, but in case Console.WriteLine("No Arguments passed"); } catch (UnauthorizedAccessException e) { e.GetBaseException(); Console.WriteLine("You do not seem to have appropiate Permissions on this direcctory"); } catch (NotSupportedException) { Console.WriteLine("The operating system is Windows CE, which does not have current directory functionality."); } catch (ArgumentException) { Console.WriteLine("Illegal characters passed as arguments! "); } catch (Exception e) { Console.WriteLine($"Unexpected error {e}"); } }
private static Document CreateDoc(AdhocWorkspace workspace, string source) => workspace.AddProject("TestProject", "C#").AddDocument("TestDocument", SourceText.From(source));
public async Task Document_Change() { using (var workspace = new WorkCoordinatorWorkspace(SolutionCrawler)) { var solution = GetInitialSolutionInfo(workspace); workspace.OnSolutionAdded(solution); await WaitWaiterAsync(workspace.ExportProvider); var id = workspace.CurrentSolution.Projects.First().DocumentIds[0]; var worker = await ExecuteOperation(workspace, w => w.ChangeDocument(id, SourceText.From("//"))); Assert.Equal(1, worker.SyntaxDocumentIds.Count); } }
public static Task <OmnisharpWorkspace> AddProjectToWorkspace(OmnisharpWorkspace workspace, string filePath, string[] frameworks, Dictionary <string, string> sourceFiles) { var versionStamp = VersionStamp.Create(); var mscorlib = MetadataReference.CreateFromFile(AssemblyFromType(typeof(object)).Location); var systemCore = MetadataReference.CreateFromFile(AssemblyFromType(typeof(Enumerable)).Location); var references = new[] { mscorlib, systemCore }; foreach (var framework in frameworks) { var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), versionStamp, "OmniSharp+" + framework, "AssemblyName", LanguageNames.CSharp, filePath, metadataReferences: references); workspace.AddProject(projectInfo); foreach (var file in sourceFiles) { var document = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id), file.Key, null, SourceCodeKind.Regular, TextLoader.From(TextAndVersion.Create(SourceText.From(file.Value), versionStamp)), file.Key); workspace.AddDocument(document); } } return(Task.FromResult(workspace)); }
protected static Project CreateProject( FileAndSource[] sources, string language = LanguageNames.CSharp, bool addLanguageSpecificCodeAnalysisReference = true, Solution addToSolution = null, string projectName = _testProjectName) { string fileNamePrefix = DefaultFilePathPrefix; string fileExt = language == LanguageNames.CSharp ? CSharpDefaultFileExt : VisualBasicDefaultExt; CompilationOptions options = language == LanguageNames.CSharp ? s_CSharpDefaultOptions : s_visualBasicDefaultOptions; ProjectId projectId = ProjectId.CreateNewId(debugName: projectName); Project project = (addToSolution ?? new AdhocWorkspace().CurrentSolution) .AddProject(projectId, projectName, projectName, language) .AddMetadataReference(projectId, s_corlibReference) .AddMetadataReference(projectId, s_systemCoreReference) .AddMetadataReference(projectId, s_systemXmlReference) .AddMetadataReference(projectId, s_systemXmlDataReference) .AddMetadataReference(projectId, s_codeAnalysisReference) .AddMetadataReference(projectId, SystemRuntimeFacadeRef) .AddMetadataReference(projectId, SystemThreadingFacadeRef) .AddMetadataReference(projectId, SystemThreadingTaskFacadeRef) //.AddMetadataReference(projectId, TestBase.SystemRef) //.AddMetadataReference(projectId, TestBase.SystemRuntimeFacadeRef) //.AddMetadataReference(projectId, TestBase.SystemThreadingFacadeRef) //.AddMetadataReference(projectId, TestBase.SystemThreadingTaskFacadeRef) .AddMetadataReference(projectId, s_immutableCollectionsReference) .AddMetadataReference(projectId, s_workspacesReference) .AddMetadataReference(projectId, s_systemDiagnosticsDebugReference) .AddMetadataReference(projectId, s_systemDataReference) .WithProjectCompilationOptions(projectId, options) .GetProject(projectId); // Enable IOperation Feature on the project var parseOptions = project.ParseOptions.WithFeatures(project.ParseOptions.Features.Concat(SpecializedCollections.SingletonEnumerable(KeyValuePair.Create("IOperation", "true")))); project = project.WithParseOptions(parseOptions); if (addLanguageSpecificCodeAnalysisReference) { MetadataReference symbolsReference = language == LanguageNames.CSharp ? s_csharpSymbolsReference : s_visualBasicSymbolsReference; project = project.AddMetadataReference(symbolsReference); } if (language == LanguageNames.VisualBasic) { project = project.AddMetadataReference(s_visualBasicReference); } int count = 0; foreach (FileAndSource source in sources) { string newFileName = source.FilePath ?? fileNamePrefix + count++ + "." + fileExt; DocumentId documentId = DocumentId.CreateNewId(projectId, debugName: newFileName); project = project.AddDocument(newFileName, SourceText.From(source.Source)).Project; } return(project); }
/// <inheritdoc/> public byte[] Compile(string code, IEnumerable <string> metadataPropertyKeys) { _ = code ?? throw new ArgumentNullException(nameof(code)); // Parse the code code = Parse(code, metadataPropertyKeys, _executionState); // Get the compilation CSharpParseOptions parseOptions = new CSharpParseOptions(); SourceText sourceText = SourceText.From(code, Encoding.UTF8); SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(sourceText, parseOptions, AssemblyName); CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary). WithSpecificDiagnosticOptions(new Dictionary <string, ReportDiagnostic> { // ensure that specific warnings about assembly references are always suppressed // https://github.com/dotnet/roslyn/issues/5501 { "CS1701", ReportDiagnostic.Suppress }, { "CS1702", ReportDiagnostic.Suppress }, { "CS1705", ReportDiagnostic.Suppress }, // we don't care about unreachable code { "CS0162", ReportDiagnostic.Suppress }, }); // For some reason, Roslyn really wants these added by filename // See http://stackoverflow.com/questions/23907305/roslyn-has-no-reference-to-system-runtime string assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location); CSharpCompilation compilation = CSharpCompilation.Create( AssemblyName, new[] { syntaxTree }, AppDomain.CurrentDomain.GetAssemblies() .Where(x => !x.IsDynamic && !string.IsNullOrEmpty(x.Location)) .Select(x => MetadataReference.CreateFromFile(x.Location)), compilationOptions) .AddReferences( MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "mscorlib.dll")), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.dll")), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Core.dll")), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Runtime.dll"))); // Emit the assembly ILogger logger = _executionState.Services.GetRequiredService <ILogger <ScriptHelper> >(); using (MemoryStream ms = new MemoryStream()) { EmitResult result = compilation.Emit(ms); // Log warnings List <string> warningMessages = result.Diagnostics .Where(x => x.Severity == DiagnosticSeverity.Warning) .Select(GetCompilationErrorMessage) .ToList(); if (warningMessages.Count > 0) { logger.LogWarning( "{0} warnings compiling script:{1}{2}", warningMessages.Count, Environment.NewLine, string.Join(Environment.NewLine, warningMessages)); } // Log errors List <string> errorMessages = result.Diagnostics .Where(x => x.Severity == DiagnosticSeverity.Error) .Select(GetCompilationErrorMessage) .ToList(); if (errorMessages.Count > 0) { logger.LogError( "{0} errors compiling script:{1}{2}", errorMessages.Count, Environment.NewLine, string.Join(Environment.NewLine, errorMessages)); } // Throw for errors or not success if (!result.Success || errorMessages.Count > 0) { throw new ScriptCompilationException(errorMessages); } ms.Seek(0, SeekOrigin.Begin); return(ms.ToArray()); } }
public override SourceText GetText(CancellationToken cancellationToken = default(CancellationToken)) { return(SourceText.From(File.ReadAllText(Path))); }
public Test() { this.ReferenceAssemblies = ReferencesHelper.DefaultReferences; this.TestBehaviors |= Microsoft.CodeAnalysis.Testing.TestBehaviors.SkipGeneratedCodeCheck; this.SolutionTransforms.Add((solution, projectId) => { var parseOptions = (CSharpParseOptions)solution.GetProject(projectId) !.ParseOptions !; solution = solution.WithProjectParseOptions(projectId, parseOptions.WithLanguageVersion(LanguageVersion.CSharp7_3)); return(solution); }); this.TestState.AdditionalFilesFactories.Add(() => { const string additionalFilePrefix = "AdditionalFiles."; return(from resourceName in Assembly.GetExecutingAssembly().GetManifestResourceNames() where resourceName.StartsWith(additionalFilePrefix, StringComparison.Ordinal) let content = ReadManifestResource(Assembly.GetExecutingAssembly(), resourceName) select(filename: resourceName.Substring(additionalFilePrefix.Length), SourceText.From(content))); }); }
public async Task CreateSolutionSnapshotId() { var code = "class A { }"; var document = new AdhocWorkspace().CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp).AddDocument("Document", SourceText.From(code)); var snapshotService = (new RemotableDataServiceFactory()).CreateService(document.Project.Solution.Workspace.Services) as IRemotableDataService; using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(document.Project.Solution, CancellationToken.None).ConfigureAwait(false)) { var syncObject = snapshot.GetRemotableData(snapshot.SolutionChecksum, CancellationToken.None); var solutionObject = await snapshotService.GetValueAsync <SolutionStateChecksums>(syncObject.Checksum).ConfigureAwait(false); VerifySynchronizationObjectInService(snapshotService, syncObject); VerifyChecksumInService(snapshotService, solutionObject.Info, WellKnownSynchronizationKind.SolutionAttributes); VerifyChecksumInService(snapshotService, solutionObject.Projects.Checksum, WellKnownSynchronizationKind.Projects); Assert.Equal(solutionObject.Projects.Count, 1); VerifySnapshotInService(snapshotService, solutionObject.Projects.ToProjectObjects(snapshotService)[0], 1, 0, 0, 0, 0); } }
public async Task TestAdditionalFile_DocumentChanged() { using (var workspace = CreateWorkspace()) { var startText = @"<setting value = ""goo"""; var newText = @"<setting value = ""goo1"""; var document = new TestHostDocument("public class C { }"); var additionalDoc = new TestHostDocument(startText); var project1 = new TestHostProject(workspace, name: "project1", documents: new[] { document }, additionalDocuments: new[] { additionalDoc }); workspace.AddTestProject(project1); var buffer = additionalDoc.GetTextBuffer(); workspace.OnAdditionalDocumentOpened(additionalDoc.Id, additionalDoc.GetOpenTextContainer()); var project = workspace.CurrentSolution.Projects.Single(); var oldVersion = await project.GetSemanticVersionAsync(); // fork the solution to introduce a change. var oldSolution = workspace.CurrentSolution; var newSolution = oldSolution.WithAdditionalDocumentText(additionalDoc.Id, SourceText.From(newText)); workspace.TryApplyChanges(newSolution); var doc = workspace.CurrentSolution.GetAdditionalDocument(additionalDoc.Id); // new text should have been pushed into buffer Assert.Equal(newText, buffer.CurrentSnapshot.GetText()); // Text changes are considered top level changes and they change the project's semantic version. Assert.Equal(await doc.GetTextVersionAsync(), await doc.GetTopLevelChangeTextVersionAsync()); Assert.NotEqual(oldVersion, await doc.Project.GetSemanticVersionAsync()); } }