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);
}
private void GenerateNotSupportedAssemblyForSourceFile(string sourceFile, string outputPath, string[] apiExclusions)
{
SyntaxTree syntaxTree;
try
{
LanguageVersion languageVersion = LanguageVersion.Default;
if (!String.IsNullOrEmpty(LangVersion) && !LanguageVersionFacts.TryParse(LangVersion, out languageVersion))
{
Log.LogError($"Invalid LangVersion value '{LangVersion}'");
return;
}
syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(sourceFile), new CSharpParseOptions(languageVersion));
}
catch (Exception ex)
{
Log.LogErrorFromException(ex, false);
return;
}
var rewriter = new NotSupportedAssemblyRewriter(Message, apiExclusions);
SyntaxNode root = rewriter.Visit(syntaxTree.GetRoot());
string text = root.GetText().ToString();
File.WriteAllText(outputPath, text);
}
public void Apply(ParseOptions options, ProjectPropertyStorage storage)
{
var csharpOptions = (CSharpParseOptions)options;
storage.SetProperty("LangVersion", nameof(CSharpProjectConfigurationProperties3.LanguageVersion),
LanguageVersionFacts.ToDisplayString(csharpOptions.SpecifiedLanguageVersion));
}
public bool CanApplyChange(ParseOptions oldOptions, ParseOptions newOptions, string?maxLangVersion)
{
var oldCSharpOptions = (CSharpParseOptions)oldOptions;
var newCSharpOptions = (CSharpParseOptions)newOptions;
// Currently, only changes to the LanguageVersion of parse options are supported.
if (oldCSharpOptions.WithLanguageVersion(newCSharpOptions.SpecifiedLanguageVersion) != newOptions)
{
return(false);
}
if (string.IsNullOrEmpty(maxLangVersion))
{
return(true);
}
else if (newCSharpOptions.LanguageVersion == LanguageVersion.Preview)
{
// It's always fine to upgrade a project to 'preview'. This allows users to try out new features to see
// how well they work, while also explicitly putting them into a *known* unsupported state (that's what
// preview is after all). Importantly, this doesn't put them into an unrealized unsupported state (for
// example, picking some combo of a real lang version that isn't supported with their chosen framework
// version).
return(true);
}
else
{
Contract.ThrowIfFalse(LanguageVersionFacts.TryParse(maxLangVersion, out var parsedMaxLanguageVersion));
return(newCSharpOptions.LanguageVersion <= parsedMaxLanguageVersion);
}
}
public bool CanApplyChange(
ParseOptions oldOptions,
ParseOptions newOptions,
string?maxLangVersion
)
{
var oldCSharpOptions = (CSharpParseOptions)oldOptions;
var newCSharpOptions = (CSharpParseOptions)newOptions;
// Currently, only changes to the LanguageVersion of parse options are supported.
if (
oldCSharpOptions.WithLanguageVersion(newCSharpOptions.SpecifiedLanguageVersion)
!= newOptions
)
{
return(false);
}
if (string.IsNullOrEmpty(maxLangVersion))
{
return(true);
}
else
{
Contract.ThrowIfFalse(
LanguageVersionFacts.TryParse(maxLangVersion, out var parsedMaxLanguageVersion)
);
return(newCSharpOptions.LanguageVersion <= parsedMaxLanguageVersion);
}
}
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);
}
protected override ParseOptions ComputeParseOptionsWithHostValues(
ParseOptions parseOptions
)
{
var symbols = GetStringOption(CompilerOptions.OPTID_CCSYMBOLS, defaultValue: "")
.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
// The base implementation of OptionsProcessor already tried this, but it didn't have the real documentation
// path so we have to do it a second time
var documentationMode = DocumentationMode.Parse;
if (GetStringOption(CompilerOptions.OPTID_XML_DOCFILE, defaultValue: null) != null)
{
documentationMode = DocumentationMode.Diagnose;
}
LanguageVersionFacts.TryParse(
GetStringOption(CompilerOptions.OPTID_COMPATIBILITY, defaultValue: ""),
out var languageVersion
);
return(((CSharpParseOptions)parseOptions)
.WithKind(SourceCodeKind.Regular)
.WithLanguageVersion(languageVersion)
.WithPreprocessorSymbols(symbols.AsImmutable())
.WithDocumentationMode(documentationMode));
}
public static LanguageVersion ToLanguageVersion(string propertyValue)
{
if (LanguageVersionFacts.TryParse(propertyValue, out var result))
{
return(result);
}
return(LanguageVersion.Default);
}
public override bool IsUpgrade(ParseOptions projectOptions, string newVersion)
{
var parseOptions = (CSharpParseOptions)projectOptions;
Contract.ThrowIfFalse(LanguageVersionFacts.TryParse(newVersion, out var parsedNewVersion));
// treat equivalent versions (one generic and one specific) to be a valid upgrade
return(parsedNewVersion.MapSpecifiedToEffectiveVersion() >= parseOptions.LanguageVersion &&
parseOptions.SpecifiedLanguageVersion.ToDisplayString() != newVersion);
}
public void Test_CodeAnalysisCSharpVersionIsSameAsUnity()
{
var unityCsVersionStr = UnityCompilerTestHelper.GetCompilerVersion();
Assert.That(unityCsVersionStr, Is.Not.Null, "something went wrong with unity_csc");
var couldParse = LanguageVersionFacts.TryParse(unityCsVersionStr, out var unityCsVersion);
Assert.That(couldParse, Is.True, $"unable to parse unity C# version: '{unityCsVersionStr}'");
var roslynTranslatorCsVersion = RoslynTranslator.LanguageVersion.MapSpecifiedToEffectiveVersion();
Assert.That(roslynTranslatorCsVersion, Is.EqualTo(unityCsVersion));
}
protected override Project GetProjectWithCorrectParseOptionsForProject(Project project, IVsHierarchy hierarchy)
{
if (project.ParseOptions is CSharpParseOptions parseOptions &&
hierarchy is IVsBuildPropertyStorage propertyStorage &&
ErrorHandler.Succeeded(propertyStorage.GetPropertyValue("LangVersion", null, (uint)_PersistStorageType.PST_PROJECT_FILE, out var langVersionString)) &&
LanguageVersionFacts.TryParse(langVersionString, out var langVersion))
{
return(project.WithParseOptions(parseOptions.WithLanguageVersion(langVersion)));
}
return(project);
}
public override bool IsUpgrade(Project project, string newVersion)
{
Contract.ThrowIfFalse(LanguageVersionFacts.TryParse(newVersion, out var parsedNewVersion));
var parseOptions = (CSharpParseOptions)project.ParseOptions !;
var mappedVersion = parsedNewVersion.MapSpecifiedToEffectiveVersion();
var workspace = project.Solution.Workspace;
// treat equivalent versions (one generic and one specific) to be a valid upgrade
return(mappedVersion >= parseOptions.LanguageVersion &&
parseOptions.SpecifiedLanguageVersion.ToDisplayString() != newVersion &&
workspace.CanApplyParseOptionChange(parseOptions, parseOptions.WithLanguageVersion(parsedNewVersion), project));
}
private static LanguageVersion RequiredVersion(ImmutableArray <Diagnostic> diagnostics)
{
LanguageVersion max = 0;
foreach (var diagnostic in diagnostics)
{
if (diagnostic.Properties.TryGetValue(DiagnosticPropertyConstants.RequiredLanguageVersion, out string requiredVersion) &&
LanguageVersionFacts.TryParse(requiredVersion, out var required))
{
max = max > required ? max : required;
}
}
return(max);
}
static MetacallEntryPoint()
{
log.Info("CSLoader Initialization - Runtime Version: "
+ RuntimeEnvironment.GetSystemVersion()
+ " - Language Version: "
+ LanguageVersionFacts.ToDisplayString(LanguageVersionFacts.MapSpecifiedToEffectiveVersion(LanguageVersion.Latest)));
#if NETCOREAPP1_0 || NETCOREAPP1_1 || NETCOREAPP1_2
loader = new Providers.LoaderV1(log);
#elif NETCOREAPP2_0 || NETCOREAPP2_1 || NETCOREAPP2_2 || NET5_0 // TODO: Implement or test support for 3
loader = new Providers.LoaderV2(log);
#else
# error "NET Core platform not supported"
#endif
}
public override Solution UpgradeProject(Project project, string newVersion)
{
var parseOptions = (CSharpParseOptions)project.ParseOptions;
if (IsUpgrade(parseOptions, newVersion))
{
Contract.ThrowIfFalse(LanguageVersionFacts.TryParse(newVersion, out var parsedNewVersion));
return(project.Solution.WithProjectParseOptions(project.Id, parseOptions.WithLanguageVersion(parsedNewVersion)));
}
else
{
// when fixing all projects in a solution, don't downgrade those with newer language versions
return(project.Solution);
}
}
public override ParseOptions CreateParseOptions(DotNetProjectConfiguration configuration)
{
var symbols = GetDefineSymbols();
if (configuration != null)
{
symbols = symbols.Concat(configuration.GetDefineSymbols()).Distinct();
}
LanguageVersionFacts.TryParse(langVersion, out LanguageVersion lv);
return(new CSharpParseOptions(
lv,
DocumentationMode.Parse,
SourceCodeKind.Regular,
ImmutableArray <string> .Empty.AddRange(symbols)
));
}
protected override ParseOptions CreateParseOptions(CommandLineArguments commandLineArguments)
{
// Get the base parse options and override the defaults with the options from state.
var options = (CSharpParseOptions)base.CreateParseOptions(commandLineArguments);
var symbols = GetStringOption(CompilerOptions.OPTID_CCSYMBOLS, defaultValue: "").Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
DocumentationMode documentationMode = DocumentationMode.Parse;
if (GetStringOption(CompilerOptions.OPTID_XML_DOCFILE, defaultValue: null) != null)
{
documentationMode = DocumentationMode.Diagnose;
}
LanguageVersionFacts.TryParse(GetStringOption(CompilerOptions.OPTID_COMPATIBILITY, defaultValue: ""), out var languageVersion);
return(options.WithKind(SourceCodeKind.Regular)
.WithLanguageVersion(languageVersion)
.WithPreprocessorSymbols(symbols.AsImmutable())
.WithDocumentationMode(documentationMode));
}
/// <summary>
/// Sets the C# language version to target when generating code.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="csharpLanguageVersion">The C# <see cref="LanguageVersion"/>.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder SetCSharpLanguageVersion(this RazorProjectEngineBuilder builder, LanguageVersion csharpLanguageVersion)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var existingFeature = builder.Features.OfType <ConfigureParserForCSharpVersionFeature>().FirstOrDefault();
if (existingFeature != null)
{
builder.Features.Remove(existingFeature);
}
// This will convert any "latest", "default" or "LatestMajor" LanguageVersions into their numerical equivalent.
var effectiveCSharpLanguageVersion = LanguageVersionFacts.MapSpecifiedToEffectiveVersion(csharpLanguageVersion);
builder.Features.Add(new ConfigureParserForCSharpVersionFeature(effectiveCSharpLanguageVersion));
return(builder);
}
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);
}
public static HashSet <string> GetAllPublicTypes(IEnumerable <string> files, IEnumerable <string> constants, string langVersion)
{
HashSet <string> types = new HashSet <string>();
LanguageVersion languageVersion = LanguageVersion.Default;
if (!string.IsNullOrEmpty(langVersion) && !LanguageVersionFacts.TryParse(langVersion, out languageVersion))
{
throw new ArgumentException($"Invalid C# language version value '{langVersion}'", nameof(langVersion));
}
var syntaxTreeCollection = GetSourceTrees(files, constants, languageVersion);
foreach (var tree in syntaxTreeCollection)
{
AddTypesFromTypeForwards(tree, types);
AddBaseTypes(tree, types);
AddTypesFromDelegates(tree, types);
}
return(types);
}
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 static CSharpParseOptions GetCSharpParseOptions(this IAnalyzerResult analyzerResult)
{
var parseOptions = new CSharpParseOptions();
// Add any constants
var constants = analyzerResult.GetProperty("DefineConstants");
if (!string.IsNullOrWhiteSpace(constants))
{
parseOptions = parseOptions
.WithPreprocessorSymbols(constants.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()));
}
// Get language version
var langVersion = analyzerResult.GetProperty("LangVersion");
if (!string.IsNullOrWhiteSpace(langVersion) &&
LanguageVersionFacts.TryParse(langVersion, out var languageVersion))
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion);
}
return(parseOptions);
}
/// <summary>
/// An error/warning directive tells the compiler to indicate a syntactic error/warning
/// at the current location.
///
/// Format: #error Error message string
/// Resulting message: from the first non-whitespace character after the directive
/// keyword until the end of the directive (aka EOD) at the line break or EOF.
/// Resulting span: [first non-whitespace char, EOD)
///
/// Examples (pipes indicate span):
/// #error |goo|
/// #error |goo|
/// #error |goo |
/// #error |goo baz|
/// #error |//goo|
/// #error |/*goo*/|
/// #error |/*goo|
/// </summary>
/// <param name="hash">The '#' token.</param>
/// <param name="keyword">The 'error' or 'warning' token.</param>
/// <param name="isActive">True if the error/warning should be recorded.</param>
/// <returns>An ErrorDirective or WarningDirective node.</returns>
private DirectiveTriviaSyntax ParseErrorOrWarningDirective(SyntaxToken hash, SyntaxToken keyword, bool isActive)
{
var eod = this.ParseEndOfDirectiveWithOptionalPreprocessingMessage();
bool isError = keyword.Kind == SyntaxKind.ErrorKeyword;
if (isActive)
{
var triviaBuilder = new System.IO.StringWriter(System.Globalization.CultureInfo.InvariantCulture);
int triviaWidth = 0;
// whitespace and single line comments are trailing trivia on the keyword, the rest
// of the error message is leading trivia on the eod.
//
bool skipping = true;
foreach (var t in keyword.TrailingTrivia)
{
if (skipping)
{
if (t.Kind == SyntaxKind.WhitespaceTrivia)
{
continue;
}
skipping = false;
}
t.WriteTo(triviaBuilder, leading: true, trailing: true);
triviaWidth += t.FullWidth;
}
foreach (var node in eod.LeadingTrivia)
{
node.WriteTo(triviaBuilder, leading: true, trailing: true);
triviaWidth += node.FullWidth;
}
//relative to leading trivia of eod
//could be negative if part of the error text comes from the trailing trivia of the keyword token
int triviaOffset = eod.GetLeadingTriviaWidth() - triviaWidth;
string errorText = triviaBuilder.ToString();
eod = this.AddError(eod, triviaOffset, triviaWidth, isError ? ErrorCode.ERR_ErrorDirective : ErrorCode.WRN_WarningDirective, errorText);
if (isError)
{
if (errorText.Equals("version", StringComparison.Ordinal))
{
Assembly assembly = typeof(CSharpCompiler).GetTypeInfo().Assembly;
string version = CommonCompiler.GetAssemblyFileVersion(assembly);
eod = this.AddError(eod, triviaOffset, triviaWidth, ErrorCode.ERR_CompilerAndLanguageVersion, version,
this.Options.SpecifiedLanguageVersion.ToDisplayString());
}
else
{
const string versionMarker = "version:";
if (errorText.StartsWith(versionMarker, StringComparison.Ordinal) &&
LanguageVersionFacts.TryParse(errorText.Substring(versionMarker.Length), out var languageVersion))
{
ErrorCode error = this.Options.LanguageVersion.GetErrorCode();
eod = this.AddError(eod, triviaOffset, triviaWidth, error, "version", new CSharpRequiredLanguageVersion(languageVersion));
}
}
}
}
if (isError)
{
return(SyntaxFactory.ErrorDirectiveTrivia(hash, keyword, eod, isActive));
}
else
{
return(SyntaxFactory.WarningDirectiveTrivia(hash, keyword, eod, isActive));
}
}
CodeCompilerResult CompileFileInternal(
CodeCompilerArguments arguments,
TextWriter log,
CancellationToken token)
{
CSharpCommandLineArguments args = null;
if (arguments.AdditionalArguments != null)
{
var splitArgs = CommandLineParser.SplitCommandLineIntoArguments(arguments.AdditionalArguments, false);
if (splitArgs.Any())
{
args = CSharpCommandLineParser.Default.Parse(splitArgs, arguments.TempDirectory, null, null);
}
}
var references = new List <MetadataReference> ();
foreach (var assemblyReference in AssemblyResolver.GetResolvedReferences(runtime, arguments.AssemblyReferences))
{
references.Add(MetadataReference.CreateFromFile(assemblyReference));
}
var parseOptions = args?.ParseOptions ?? new CSharpParseOptions();
if (arguments.LangVersion != null)
{
if (LanguageVersionFacts.TryParse(arguments.LangVersion, out var langVersion))
{
parseOptions = parseOptions.WithLanguageVersion(langVersion);
}
else
{
throw new System.Exception($"Unknown value '{arguments.LangVersion}' for langversion");
}
}
else
{
// need to update this when updating referenced roslyn binaries
CSharpLangVersionHelper.GetBestSupportedLangVersion(runtime, CSharpLangVersion.v9_0);
}
var syntaxTrees = new List <SyntaxTree> ();
foreach (var sourceFile in arguments.SourceFiles)
{
using var stream = File.OpenRead(sourceFile);
var sourceText = SourceText.From(stream, Encoding.UTF8, canBeEmbedded: true);
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(sourceText, parseOptions, cancellationToken: token, path: sourceFile);
syntaxTrees.Add(syntaxTree);
}
var compilationOptions = (args?.CompilationOptions ?? new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.WithOutputKind(OutputKind.DynamicallyLinkedLibrary);
var compilation = CSharpCompilation.Create(
"GeneratedTextTransformation",
syntaxTrees,
references,
compilationOptions
);
EmitOptions emitOptions = args?.EmitOptions ?? new EmitOptions();
if (arguments.Debug)
{
var embeddedTexts = syntaxTrees.Select(st => EmbeddedText.FromSource(st.FilePath, st.GetText())).ToList();
emitOptions = emitOptions.WithDebugInformationFormat(DebugInformationFormat.Embedded);
}
using var fs = File.OpenWrite(arguments.OutputPath);
EmitResult result = compilation.Emit(fs, options: emitOptions, cancellationToken: token);
if (result.Success)
{
return(new CodeCompilerResult {
Output = new List <string> (),
Success = true,
Errors = new List <CodeCompilerError> ()
});
}
var failures = result.Diagnostics.Where(x => x.IsWarningAsError || x.Severity == DiagnosticSeverity.Error);
var errors = failures.Select(x => {
var location = x.Location.GetMappedLineSpan();
var startLinePosition = location.StartLinePosition;
var endLinePosition = location.EndLinePosition;
return(new CodeCompilerError {
Message = x.GetMessage(),
Column = startLinePosition.Character,
Line = startLinePosition.Line,
EndLine = endLinePosition.Line,
EndColumn = endLinePosition.Character,
IsError = x.Severity == DiagnosticSeverity.Error,
Origin = location.Path
});
}).ToList();
return(new CodeCompilerResult {
Success = false,
Output = new List <string> (),
Errors = errors
});
}
internal static string LanguageVersionToString(LanguageVersion value) => LanguageVersionFacts.ToDisplayString(value);
private int ExecuteCore(
RazorConfiguration configuration,
string projectDirectory,
string tagHelperManifest,
SourceItem[] sourceItems)
{
tagHelperManifest = Path.Combine(projectDirectory, tagHelperManifest);
var tagHelpers = GetTagHelpers(tagHelperManifest);
var compositeFileSystem = new CompositeRazorProjectFileSystem(new[]
{
GetVirtualRazorProjectSystem(sourceItems),
RazorProjectFileSystem.Create(projectDirectory),
});
var success = true;
var engine = RazorProjectEngine.Create(configuration, compositeFileSystem, b =>
{
b.Features.Add(new StaticTagHelperFeature()
{
TagHelpers = tagHelpers,
});
b.Features.Add(new DefaultTypeNameFeature());
if (GenerateDeclaration.HasValue())
{
b.Features.Add(new SetSuppressPrimaryMethodBodyOptionFeature());
}
if (RootNamespace.HasValue())
{
b.SetRootNamespace(RootNamespace.Value());
}
if (CSharpLanguageVersion.HasValue())
{
// Only set the C# language version if one was specified, otherwise it defaults to whatever
// value was set in the corresponding RazorConfiguration's extensions.
var rawLanguageVersion = CSharpLanguageVersion.Value();
if (LanguageVersionFacts.TryParse(rawLanguageVersion, out var csharpLanguageVersion))
{
b.SetCSharpLanguageVersion(csharpLanguageVersion);
}
else
{
success = false;
Error.WriteLine($"Unknown C# language version {rawLanguageVersion}.");
}
}
});
var results = GenerateCode(engine, sourceItems);
foreach (var result in results)
{
var errorCount = result.CSharpDocument.Diagnostics.Count;
for (var i = 0; i < errorCount; i++)
{
var error = result.CSharpDocument.Diagnostics[i];
if (error.Severity == RazorDiagnosticSeverity.Error)
{
success = false;
}
if (i < 100)
{
Error.WriteLine(error.ToString());
// Only show the first 100 errors to prevent massive string allocations.
if (i == 99)
{
Error.WriteLine($"And {errorCount - i + 1} more warnings/errors.");
}
}
}
if (success)
{
// Only output the file if we generated it without errors.
var outputFilePath = result.InputItem.OutputPath;
File.WriteAllText(outputFilePath, result.CSharpDocument.GeneratedCode);
}
}
return(success ? ExitCodeSuccess : ExitCodeFailureRazorError);
}
