private CSharpParseOptions GetParseOptions(DependencyContextCompilationOptions dependencyContextOptions)
{
var configurationSymbol = isDevelopment ? "DEBUG" : "RELEASE";
var defines = dependencyContextOptions.Defines.Concat(new[] { configurationSymbol });
var parseOptions = new CSharpParseOptions(preprocessorSymbols: defines);
#if NETCORE
parseOptions = parseOptions.WithLanguageVersion(LanguageVersion.CSharp8);
#else
if (!string.IsNullOrEmpty(dependencyContextOptions.LanguageVersion))
{
if (LanguageVersionFacts.TryParse(dependencyContextOptions.LanguageVersion, out var languageVersion))
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion);
}
else
{
Debug.Fail($"LanguageVersion {languageVersion} specified in the deps file could not be parsed.");
}
}
#endif
return(parseOptions);
}
private static CSharpParseOptions GetParseOptions(
IWebHostEnvironment hostingEnvironment,
DependencyContextCompilationOptions dependencyContextOptions)
{
var configurationSymbol = hostingEnvironment.IsDevelopment() ? "DEBUG" : "RELEASE";
var defines = dependencyContextOptions.Defines.Concat(new[] { configurationSymbol });
var parseOptions = new CSharpParseOptions(preprocessorSymbols: defines);
if (string.IsNullOrEmpty(dependencyContextOptions.LanguageVersion))
{
// If the user does not specify a LanguageVersion, assume CSharp 8.0. This matches the language version Razor 3.0 targets by default.
parseOptions = parseOptions.WithLanguageVersion(LanguageVersion.CSharp8);
}
else if (LanguageVersionFacts.TryParse(dependencyContextOptions.LanguageVersion, out var languageVersion))
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion);
}
else
{
Debug.Fail($"LanguageVersion {languageVersion} specified in the deps file could not be parsed.");
}
return(parseOptions);
}
private static CSharpParseOptions GetParseOptions(
IWebHostEnvironment hostingEnvironment,
DependencyContextCompilationOptions dependencyContextOptions)
{
var configurationSymbol = hostingEnvironment.IsDevelopment() ? "DEBUG" : "RELEASE";
var defines = dependencyContextOptions.Defines.Concat(new[] { configurationSymbol });
var parseOptions = new CSharpParseOptions(preprocessorSymbols: defines);
if (string.IsNullOrEmpty(dependencyContextOptions.LanguageVersion))
{
// During preview releases, Roslyn assumes Preview language version for netcoreapp3.0 targeting projects.
// We will match the behavior if the project does not specify a value for C# language (e.g. if you're using Razor compilation in a F# project).
// Prior to 3.0 RTM, this value needs to be changed to "Latest". This is tracked via https://github.com/aspnet/AspNetCore/issues/9129
parseOptions = parseOptions.WithLanguageVersion(LanguageVersion.Preview);
}
else if (LanguageVersionFacts.TryParse(dependencyContextOptions.LanguageVersion, out var languageVersion))
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion);
}
else
{
Debug.Fail($"LanguageVersion {languageVersion} specified in the deps file could not be parsed.");
}
return(parseOptions);
}
public DependencyContext(string target, string runtime, CompilationOptions compilationOptions, CompilationLibrary[] compileLibraries, RuntimeLibrary[] runtimeLibraries)
{
Target = target;
Runtime = runtime;
CompilationOptions = compilationOptions;
CompileLibraries = compileLibraries;
RuntimeLibraries = runtimeLibraries;
}
public TestCSharpCompiler(
RazorReferenceManager referenceManager,
IWebHostEnvironment hostingEnvironment,
DependencyContextCompilationOptions options)
: base(referenceManager, hostingEnvironment)
{
_options = options;
}
private EmitOptions GetEmitOptions(DependencyContextCompilationOptions dependencyContextOptions)
{
// Assume we're always producing pdbs unless DebugType = none
_emitPdb = true;
DebugInformationFormat debugInformationFormat;
if (string.IsNullOrEmpty(dependencyContextOptions.DebugType))
{
debugInformationFormat = SymbolsUtility.SupportsFullPdbGeneration() ?
DebugInformationFormat.Pdb :
DebugInformationFormat.PortablePdb;
}
else
{
// Based on https://github.com/dotnet/roslyn/blob/1d28ff9ba248b332de3c84d23194a1d7bde07e4d/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs#L624-L640
switch (dependencyContextOptions.DebugType.ToLower())
{
case "none":
// There isn't a way to represent none in DebugInformationFormat.
// We'll set EmitPdb to false and let callers handle it by setting a null pdb-stream.
_emitPdb = false;
return(new EmitOptions());
case "portable":
debugInformationFormat = DebugInformationFormat.PortablePdb;
break;
case "embedded":
// Roslyn does not expose enough public APIs to produce a binary with embedded pdbs.
// We'll produce PortablePdb instead to continue providing a reasonable user experience.
debugInformationFormat = DebugInformationFormat.PortablePdb;
break;
case "full":
case "pdbonly":
debugInformationFormat = SymbolsUtility.SupportsFullPdbGeneration() ?
DebugInformationFormat.Pdb :
DebugInformationFormat.PortablePdb;
break;
default:
throw new InvalidOperationException(Resources.FormatUnsupportedDebugInformationFormat(dependencyContextOptions.DebugType));
}
}
var emitOptions = new EmitOptions(debugInformationFormat: debugInformationFormat);
return(emitOptions);
}
private static CSharpCompilationOptions GetCompilationOptions(
IWebHostEnvironment hostingEnvironment,
DependencyContextCompilationOptions dependencyContextOptions)
{
var csharpCompilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
// Disable 1702 until roslyn turns this off by default
csharpCompilationOptions = csharpCompilationOptions.WithSpecificDiagnosticOptions(
new Dictionary <string, ReportDiagnostic>
{
{ "CS1701", ReportDiagnostic.Suppress }, // Binding redirects
{ "CS1702", ReportDiagnostic.Suppress },
{ "CS1705", ReportDiagnostic.Suppress }
});
if (dependencyContextOptions.AllowUnsafe.HasValue)
{
csharpCompilationOptions = csharpCompilationOptions.WithAllowUnsafe(
dependencyContextOptions.AllowUnsafe.Value);
}
OptimizationLevel optimizationLevel;
if (dependencyContextOptions.Optimize.HasValue)
{
optimizationLevel = dependencyContextOptions.Optimize.Value ?
OptimizationLevel.Release :
OptimizationLevel.Debug;
}
else
{
optimizationLevel = hostingEnvironment.IsDevelopment() ?
OptimizationLevel.Debug :
OptimizationLevel.Release;
}
csharpCompilationOptions = csharpCompilationOptions.WithOptimizationLevel(optimizationLevel);
if (dependencyContextOptions.WarningsAsErrors.HasValue)
{
var reportDiagnostic = dependencyContextOptions.WarningsAsErrors.Value ?
ReportDiagnostic.Error :
ReportDiagnostic.Default;
csharpCompilationOptions = csharpCompilationOptions.WithGeneralDiagnosticOption(reportDiagnostic);
}
return(csharpCompilationOptions);
}
private CSharpParseOptions GetParseOptions(DependencyContextCompilationOptions dependencyContextOptions)
{
var configurationSymbol = _isDevelopment ? "DEBUG" : "RELEASE";
var defines = dependencyContextOptions.Defines.Concat(new[] { configurationSymbol });
var parseOptions = new CSharpParseOptions(preprocessorSymbols: defines);
LanguageVersion languageVersion;
if (!string.IsNullOrEmpty(dependencyContextOptions.LanguageVersion) &&
Enum.TryParse(dependencyContextOptions.LanguageVersion, ignoreCase: true, result: out languageVersion))
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion);
}
return(parseOptions);
}
private JObject WriteCompilationOptions(CompilationOptions compilationOptions)
{
var o = new JObject();
if (compilationOptions.Defines != null)
{
o[DependencyContextStrings.DefinesPropertyName] = new JArray(compilationOptions.Defines);
}
if (compilationOptions.LanguageVersion != null)
{
o[DependencyContextStrings.LanguageVersionPropertyName] = compilationOptions.LanguageVersion;
}
if (compilationOptions.Platform != null)
{
o[DependencyContextStrings.PlatformPropertyName] = compilationOptions.Platform;
}
if (compilationOptions.AllowUnsafe != null)
{
o[DependencyContextStrings.AllowUnsafePropertyName] = compilationOptions.AllowUnsafe;
}
if (compilationOptions.WarningsAsErrors != null)
{
o[DependencyContextStrings.WarningsAsErrorsPropertyName] = compilationOptions.WarningsAsErrors;
}
if (compilationOptions.Optimize != null)
{
o[DependencyContextStrings.OptimizePropertyName] = compilationOptions.Optimize;
}
if (compilationOptions.KeyFile != null)
{
o[DependencyContextStrings.KeyFilePropertyName] = compilationOptions.KeyFile;
}
if (compilationOptions.DelaySign != null)
{
o[DependencyContextStrings.DelaySignPropertyName] = compilationOptions.DelaySign;
}
if (compilationOptions.PublicSign != null)
{
o[DependencyContextStrings.PublicSignPropertyName] = compilationOptions.PublicSign;
}
if (compilationOptions.EmitEntryPoint != null)
{
o[DependencyContextStrings.EmitEntryPointPropertyName] = compilationOptions.EmitEntryPoint;
}
return o;
}
private static void SetParseOptions(
RazorViewEngineOptions options,
DependencyContextOptions compilationOptions)
{
var parseOptions = options.ParseOptions;
parseOptions = parseOptions.WithPreprocessorSymbols(
parseOptions.PreprocessorSymbolNames.Concat(compilationOptions.Defines));
LanguageVersion languageVersion;
if (!string.IsNullOrEmpty(compilationOptions.LanguageVersion) &&
Enum.TryParse(compilationOptions.LanguageVersion, ignoreCase: true, result: out languageVersion))
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion);
}
options.ParseOptions = parseOptions;
}
CSharpParseOptions GetParseOptions(DependencyContextCompilationOptions dependencyContextOptions)
{
var configurationSymbol = "RELEASE";
var defines = dependencyContextOptions.Defines.Concat(new[] { configurationSymbol });
var parseOptions = new CSharpParseOptions(preprocessorSymbols: defines);
if (!string.IsNullOrEmpty(dependencyContextOptions.LanguageVersion))
{
if (LanguageVersionFacts.TryParse(dependencyContextOptions.LanguageVersion, out var languageVersion))
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion);
}
else
{
System.Console.WriteLine($"LanguageVersion {languageVersion} specified in the deps file could not be parsed.");
}
}
return(parseOptions);
}
private EmitOptions GetEmitOptions(DependencyContextCompilationOptions dependencyContextOptions)
{
DebugInformationFormat debugInformationFormat;
if (string.IsNullOrEmpty(dependencyContextOptions.DebugType))
{
debugInformationFormat = SymbolsUtility.SupportsFullPdbGeneration() ?
DebugInformationFormat.Pdb :
DebugInformationFormat.PortablePdb;
}
else
{
// Based on https://github.com/dotnet/roslyn/blob/1d28ff9ba248b332de3c84d23194a1d7bde07e4d/src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs#L624-L640
switch (dependencyContextOptions.DebugType.ToLower())
{
case "portable":
debugInformationFormat = DebugInformationFormat.PortablePdb;
break;
case "embedded":
debugInformationFormat = DebugInformationFormat.Embedded;
break;
case "full":
case "pdbonly":
debugInformationFormat = SymbolsUtility.SupportsFullPdbGeneration() ?
DebugInformationFormat.Pdb :
DebugInformationFormat.PortablePdb;
break;
default:
throw new InvalidOperationException(Resources.FormatUnsupportedDebugInformationFormat(dependencyContextOptions.DebugType));
}
}
var emitOptions = new EmitOptions(debugInformationFormat: debugInformationFormat);
return(emitOptions);
}
private static void SetCompilationOptions(
RazorViewEngineOptions options,
DependencyContextOptions compilationOptions)
{
var roslynOptions = options.CompilationOptions;
// Disable 1702 until roslyn turns this off by default
roslynOptions = roslynOptions.WithSpecificDiagnosticOptions(
new Dictionary <string, ReportDiagnostic>
{
{ "CS1701", ReportDiagnostic.Suppress }, // Binding redirects
{ "CS1702", ReportDiagnostic.Suppress },
{ "CS1705", ReportDiagnostic.Suppress }
});
if (compilationOptions.AllowUnsafe.HasValue)
{
roslynOptions = roslynOptions.WithAllowUnsafe(compilationOptions.AllowUnsafe.Value);
}
if (compilationOptions.Optimize.HasValue)
{
var optimizationLevel = compilationOptions.Optimize.Value ?
OptimizationLevel.Release :
OptimizationLevel.Debug;
roslynOptions = roslynOptions.WithOptimizationLevel(optimizationLevel);
}
if (compilationOptions.WarningsAsErrors.HasValue)
{
var reportDiagnostic = compilationOptions.WarningsAsErrors.Value ?
ReportDiagnostic.Error :
ReportDiagnostic.Default;
roslynOptions = roslynOptions.WithGeneralDiagnosticOption(reportDiagnostic);
}
options.CompilationOptions = roslynOptions;
}
private static CSharpParseOptions GetParseOptions(
IWebHostEnvironment hostingEnvironment,
DependencyContextCompilationOptions dependencyContextOptions)
{
var configurationSymbol = hostingEnvironment.IsDevelopment() ? "DEBUG" : "RELEASE";
var defines = dependencyContextOptions.Defines.Concat(new[] { configurationSymbol });
var parseOptions = new CSharpParseOptions(preprocessorSymbols: defines);
if (!string.IsNullOrEmpty(dependencyContextOptions.LanguageVersion))
{
if (LanguageVersionFacts.TryParse(dependencyContextOptions.LanguageVersion, out var languageVersion))
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion);
}
else
{
Debug.Fail($"LanguageVersion {languageVersion} specified in the deps file could not be parsed.");
}
}
return(parseOptions);
}
public DependencyContext(string targetFramework,
string runtime,
bool isPortable,
CompilationOptions compilationOptions,
IEnumerable<CompilationLibrary> compileLibraries,
IEnumerable<RuntimeLibrary> runtimeLibraries,
IEnumerable<KeyValuePair<string, string[]>> runtimeGraph)
{
if (targetFramework == null)
{
throw new ArgumentNullException(nameof(targetFramework));
}
if (runtime == null)
{
throw new ArgumentNullException(nameof(runtime));
}
if (compileLibraries == null)
{
throw new ArgumentNullException(nameof(compileLibraries));
}
if (runtimeLibraries == null)
{
throw new ArgumentNullException(nameof(runtimeLibraries));
}
if (runtimeGraph == null)
{
throw new ArgumentNullException(nameof(runtimeGraph));
}
TargetFramework = targetFramework;
Runtime = runtime;
IsPortable = isPortable;
CompilationOptions = compilationOptions;
CompileLibraries = compileLibraries.ToArray();
RuntimeLibraries = runtimeLibraries.ToArray();
RuntimeGraph = runtimeGraph.ToArray();
}
private DependencyContext Read(JsonTextReader reader)
{
var runtime = string.Empty;
var framework = string.Empty;
var isPortable = true;
string runtimeTargetName = null;
string runtimeSignature = null;
reader.ReadStartObject();
CompilationOptions compilationOptions = null;
List <Target> targets = null;
Dictionary <string, LibraryStub> libraryStubs = null;
List <RuntimeFallbacks> runtimeFallbacks = null;
while (reader.Read() && reader.TokenType == JsonToken.PropertyName)
{
switch ((string)reader.Value)
{
case DependencyContextStrings.RuntimeTargetPropertyName:
ReadRuntimeTarget(reader, out runtimeTargetName, out runtimeSignature);
break;
case DependencyContextStrings.CompilationOptionsPropertName:
compilationOptions = ReadCompilationOptions(reader);
break;
case DependencyContextStrings.TargetsPropertyName:
targets = ReadTargets(reader);
break;
case DependencyContextStrings.LibrariesPropertyName:
libraryStubs = ReadLibraries(reader);
break;
case DependencyContextStrings.RuntimesPropertyName:
runtimeFallbacks = ReadRuntimes(reader);
break;
}
}
if (compilationOptions == null)
{
compilationOptions = CompilationOptions.Default;
}
Target runtimeTarget = SelectRuntimeTarget(targets, runtimeTargetName);
runtimeTargetName = runtimeTarget?.Name;
if (runtimeTargetName != null)
{
var seperatorIndex = runtimeTargetName.IndexOf(DependencyContextStrings.VersionSeperator);
if (seperatorIndex > -1 && seperatorIndex < runtimeTargetName.Length)
{
runtime = runtimeTargetName.Substring(seperatorIndex + 1);
framework = runtimeTargetName.Substring(0, seperatorIndex);
isPortable = false;
}
else
{
framework = runtimeTargetName;
}
}
Target compileTarget = null;
var ridlessTarget = targets.FirstOrDefault(t => !IsRuntimeTarget(t.Name));
if (ridlessTarget != null)
{
compileTarget = ridlessTarget;
if (runtimeTarget == null)
{
runtimeTarget = compileTarget;
framework = ridlessTarget.Name;
}
}
if (runtimeTarget == null)
{
throw new FormatException("No runtime target found");
}
return(new DependencyContext(
new TargetInfo(framework, runtime, runtimeSignature, isPortable),
compilationOptions,
CreateLibraries(compileTarget?.Libraries, false, libraryStubs).Cast <CompilationLibrary>().ToArray(),
CreateLibraries(runtimeTarget.Libraries, true, libraryStubs).Cast <RuntimeLibrary>().ToArray(),
runtimeFallbacks ?? Enumerable.Empty <RuntimeFallbacks>()));
}
