public void BeforeCompile(IBeforeCompileContext context)
{
// Firstly, I need to resolve the namespace of the ModuleProvider instance in this current compilation.
string ns = GetModuleProviderNamespace(context.Compilation.SyntaxTrees);
// Next, get all the available modules in assembly and compilation references.
var modules = GetAvailableModules(context.Compilation).ToList();
// Map them to a collection of statements
var statements = modules.Select(m => F.ParseStatement("AddModule<" + module + ">();")).ToList();
// Now, I'll create the dynamic implementation as a private class.
var cu = F.CompilationUnit()
.AddMembers(
F.NamespaceDeclaration(F.IdentifierName(ns))
.AddMembers(
F.ClassDeclaration("ModuleProvider")
.WithModifiers(F.TokenList(F.Token(K.PartialKeyword)))
.AddMembers(
F.MethodDeclaration(F.PredefinedType(F.Token(K.VoidKeyword)), "Setup")
.WithModifiers(
F.TokenList(
F.Token(K.ProtectedKeyword),
F.Token(K.OverrideKeyword)))
.WithBody(F.Block(statements))
)
)
)
.NormalizeWhitespace(indentation("\t"));
var tree = T.Create(cu);
context.Compilation = context.Compilation.AddSyntaxTrees(tree);
}
public void BeforeCompile(IBeforeCompileContext context)
{
JObject rawProjectFile = null;
using (var fs = File.OpenRead(context.ProjectContext.ProjectFilePath))
{
rawProjectFile = JObject.Load(new JsonTextReader(new StreamReader(fs)));
}
var excludePatterns = PatternsCollectionHelper.GetPatternsCollection(
rawProjectFile,
context.ProjectContext.ProjectDirectory,
context.ProjectContext.ProjectFilePath,
"exclude",
DefaultExcludePatterns);
var matcher = new Matcher();
matcher.AddInclude("**/*.resx").AddExcludePatterns(excludePatterns);
var resXFiles = matcher.GetResultsInFullPath(context.ProjectContext.ProjectDirectory);
foreach (var resXFile in resXFiles)
{
WriteResourceFile(resXFile);
}
}
public void BeforeCompile(IBeforeCompileContext context)
{
JObject rawProjectFile = null;
using (var fs = File.OpenRead(context.ProjectContext.ProjectFilePath))
{
rawProjectFile = JObject.Load(new JsonTextReader(new StreamReader(fs)));
}
var excludePatterns = PatternsCollectionHelper.GetPatternsCollection(
rawProjectFile,
context.ProjectContext.ProjectDirectory,
context.ProjectContext.ProjectFilePath,
"exclude",
DefaultExcludePatterns);
var matcher = new Matcher();
matcher.AddInclude("**/*.resx").AddExcludePatterns(excludePatterns);
var resXFiles = matcher.GetResultsInFullPath(context.ProjectContext.ProjectDirectory);
foreach (var resXFile in resXFiles)
{
WriteResourceFile(resXFile);
}
}
public void BeforeCompile(IBeforeCompileContext context)
{
string keyPath = Environment.GetEnvironmentVariable("NUGET_BUILD_KEY_PATH");
string delaySignString = Environment.GetEnvironmentVariable("NUGET_BUILD_DELAY_SIGN");
if (!string.IsNullOrEmpty(keyPath))
{
FileInfo keyFile = new FileInfo(keyPath);
if (keyFile.Exists)
{
bool delaySign = delaySignString != null && StringComparer.OrdinalIgnoreCase.Equals("true", delaySignString);
// Console.WriteLine("Signing assembly with: {0} Delay sign: {1}", keyFile.FullName, delaySign ? "true" : "false");
var parms = new CspParameters();
parms.KeyNumber = 2;
var provider = new RSACryptoServiceProvider(parms);
byte[] array = provider.ExportCspBlob(!provider.PublicOnly);
var strongNameProvider = new DesktopStrongNameProvider();
var options = context.Compilation.Options.WithStrongNameProvider(strongNameProvider)
.WithCryptoKeyFile(keyFile.FullName)
.WithDelaySign(delaySign);
// Enfore viral strong naming
var specificDiagnosticOptions = new Dictionary <string, ReportDiagnostic>(options.SpecificDiagnosticOptions);
specificDiagnosticOptions["CS8002"] = ReportDiagnostic.Error;
options = options.WithSpecificDiagnosticOptions(specificDiagnosticOptions);
context.Compilation = context.Compilation.WithOptions(options);
}
else
{
// The key was not found. Throw a compile error.
var descriptor = new DiagnosticDescriptor(
id: "SN1001",
title: "Missing key file",
messageFormat: "Key file '{0}' could not be found",
category: "CA1001: \"StrongNaming\"",
defaultSeverity: DiagnosticSeverity.Error,
isEnabledByDefault: true);
// TODO: what should this reference for the location?
var textSpan = new TextSpan();
var position = new LinePosition(0, 0);
var span = new LinePositionSpan(position, position);
var location = Location.Create(context.ProjectContext.ProjectFilePath, textSpan, span);
var diagnsotic = Diagnostic.Create(descriptor, location, keyPath);
context.Diagnostics.Add(diagnsotic);
}
}
}
public void BeforeCompile(IBeforeCompileContext context)
{
string keyPath = Environment.GetEnvironmentVariable("NUGET_BUILD_KEY_PATH");
string delaySignString = Environment.GetEnvironmentVariable("NUGET_BUILD_DELAY_SIGN");
if (!string.IsNullOrEmpty(keyPath))
{
FileInfo keyFile = new FileInfo(keyPath);
if (keyFile.Exists)
{
bool delaySign = delaySignString != null && StringComparer.OrdinalIgnoreCase.Equals("true", delaySignString);
// Console.WriteLine("Signing assembly with: {0} Delay sign: {1}", keyFile.FullName, delaySign ? "true" : "false");
var parms = new CspParameters();
parms.KeyNumber = 2;
var provider = new RSACryptoServiceProvider(parms);
byte[] array = provider.ExportCspBlob(!provider.PublicOnly);
var strongNameProvider = new DesktopStrongNameProvider();
var options = context.Compilation.Options.WithStrongNameProvider(strongNameProvider)
.WithCryptoKeyFile(keyFile.FullName)
.WithDelaySign(delaySign);
// Enfore viral strong naming
var specificDiagnosticOptions = new Dictionary<string, ReportDiagnostic>(options.SpecificDiagnosticOptions);
specificDiagnosticOptions["CS8002"] = ReportDiagnostic.Error;
options = options.WithSpecificDiagnosticOptions(specificDiagnosticOptions);
context.Compilation = context.Compilation.WithOptions(options);
}
else
{
// The key was not found. Throw a compile error.
var descriptor = new DiagnosticDescriptor(
id: "SN1001",
title: "Missing key file",
messageFormat: "Key file '{0}' could not be found",
category: "CA1001: \"StrongNaming\"",
defaultSeverity: DiagnosticSeverity.Error,
isEnabledByDefault: true);
// TODO: what should this reference for the location?
var textSpan = new TextSpan();
var position = new LinePosition(0, 0);
var span = new LinePositionSpan(position, position);
var location = Location.Create(context.ProjectContext.ProjectFilePath, textSpan, span);
var diagnsotic = Diagnostic.Create(descriptor, location, keyPath);
context.Diagnostics.Add(diagnsotic);
}
}
}
public void BeforeCompile(IBeforeCompileContext context)
{
var options = CSharpParseOptions.Default
.WithLanguageVersion(context.CSharpCompilation.LanguageVersion);
context.CSharpCompilation = context.CSharpCompilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(@"
public class Foo
{
public string Message
{
get { return ""Metaprogrammg!""; }
}
}", options));
}
public RazorPreCompiler(
[NotNull] IBeforeCompileContext compileContext,
[NotNull] IAssemblyLoadContextAccessor loadContextAccessor,
[NotNull] IFileProvider fileProvider,
[NotNull] IMemoryCache precompilationCache,
[NotNull] CompilationSettings compilationSettings)
{
CompileContext = compileContext;
LoadContext = loadContextAccessor.GetLoadContext(GetType().GetTypeInfo().Assembly);
FileProvider = fileProvider;
CompilationSettings = compilationSettings;
PreCompilationCache = precompilationCache;
TagHelperTypeResolver = new PrecompilationTagHelperTypeResolver(CompileContext, LoadContext);
}
public virtual void CompileViews([NotNull] IBeforeCompileContext context)
{
var descriptors = CreateCompilationDescriptors(context);
if (descriptors.Any())
{
var collectionGenerator = new RazorFileInfoCollectionGenerator(
descriptors,
CompilationSettings);
var tree = collectionGenerator.GenerateCollection();
context.CSharpCompilation = context.CSharpCompilation.AddSyntaxTrees(tree);
}
}
public virtual void BeforeCompile(IBeforeCompileContext context)
{
var appEnv = _appServices.GetRequiredService <IApplicationEnvironment>();
var setup = new RazorViewEngineOptionsSetup(appEnv);
var sc = new ServiceCollection();
sc.ConfigureOptions(setup);
sc.AddMvc();
var viewCompiler = new RazorPreCompiler(BuildFallbackServiceProvider(sc, _appServices));
viewCompiler.CompileViews(context);
}
public void BeforeCompile(IBeforeCompileContext context)
{
var options = CSharpParseOptions.Default
.WithLanguageVersion(context.CSharpCompilation.LanguageVersion);
context.CSharpCompilation = context.CSharpCompilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(@"
public class Foo
{
public string Message
{
get { return ""Metaprogrammg!""; }
}
}", options));
}
public virtual void CompileViews([NotNull] IBeforeCompileContext context)
{
var descriptors = CreateCompilationDescriptors(context);
if (descriptors.Count > 0)
{
var collectionGenerator = new RazorFileInfoCollectionGenerator(
descriptors,
SyntaxTreeGenerator.GetParseOptions(context.CSharpCompilation));
var tree = collectionGenerator.GenerateCollection();
context.CSharpCompilation = context.CSharpCompilation.AddSyntaxTrees(tree);
}
}
public virtual void BeforeCompile(IBeforeCompileContext context)
{
var sc = new ServiceCollection();
var appEnv = _appServices.GetRequiredService <IApplicationEnvironment>();
var setup = new RazorViewEngineOptionsSetup(appEnv);
var accessor = new OptionsManager <RazorViewEngineOptions>(new[] { setup });
sc.AddInstance <IOptions <RazorViewEngineOptions> >(accessor);
sc.Add(MvcServices.GetDefaultServices());
var sp = sc.BuildServiceProvider(_appServices);
var viewCompiler = new RazorPreCompiler(sp);
viewCompiler.CompileViews(context);
}
public virtual void BeforeCompile(IBeforeCompileContext context)
{
var applicationEnvironment = _appServices.GetRequiredService <IApplicationEnvironment>();
var compilerOptionsProvider = _appServices.GetRequiredService <ICompilerOptionsProvider>();
var compilationSettings = compilerOptionsProvider.GetCompilationSettings(applicationEnvironment);
var setup = new RazorViewEngineOptionsSetup(applicationEnvironment);
var sc = new ServiceCollection();
sc.ConfigureOptions(setup);
sc.AddMvc();
var serviceProvider = BuildFallbackServiceProvider(sc, _appServices);
var viewCompiler = new RazorPreCompiler(serviceProvider, _memoryCache, compilationSettings);
viewCompiler.CompileViews(context);
}
protected virtual IEnumerable <RazorFileInfo> CreateCompilationDescriptors(
[NotNull] IBeforeCompileContext context)
{
var filesToProcess = new List <RelativeFileInfo>();
GetFileInfosRecursive(root: string.Empty, razorFiles: filesToProcess);
var razorFiles = new RazorFileInfo[filesToProcess.Count];
var syntaxTrees = new SyntaxTree[filesToProcess.Count];
var parallelOptions = new ParallelOptions {
MaxDegreeOfParallelism = MaxDegreesOfParallelism
};
var diagnosticsLock = new object();
Parallel.For(0, filesToProcess.Count, parallelOptions, index =>
{
var file = filesToProcess[index];
var cacheEntry = PreCompilationCache.GetOrSet(file.RelativePath,
file,
OnCacheMiss);
if (cacheEntry != null)
{
if (cacheEntry.Success)
{
syntaxTrees[index] = cacheEntry.SyntaxTree;
razorFiles[index] = cacheEntry.FileInfo;
}
else
{
lock (diagnosticsLock)
{
foreach (var diagnostic in cacheEntry.Diagnostics)
{
context.Diagnostics.Add(diagnostic);
}
}
}
}
});
context.CSharpCompilation = context.CSharpCompilation
.AddSyntaxTrees(syntaxTrees.Where(tree => tree != null));
return(razorFiles.Where(file => file != null));
}
/// <inheritdoc />
/// <remarks>Pre-compiles all Razor views in the application.</remarks>
public virtual void BeforeCompile(IBeforeCompileContext context)
{
var compilerOptionsProvider = _appServices.GetRequiredService<ICompilerOptionsProvider>();
var loadContextAccessor = _appServices.GetRequiredService<IAssemblyLoadContextAccessor>();
var compilationSettings = GetCompilationSettings(compilerOptionsProvider, context.ProjectContext);
var fileProvider = new PhysicalFileProvider(context.ProjectContext.ProjectDirectory);
var viewCompiler = new RazorPreCompiler(
context,
loadContextAccessor,
fileProvider,
_memoryCache,
compilationSettings)
{
GenerateSymbols = GenerateSymbols
};
viewCompiler.CompileViews();
}
/// <inheritdoc />
/// <remarks>Pre-compiles all Razor views in the application.</remarks>
public virtual void BeforeCompile(IBeforeCompileContext context)
{
var compilerOptionsProvider = _appServices.GetRequiredService <ICompilerOptionsProvider>();
var loadContextAccessor = _appServices.GetRequiredService <IAssemblyLoadContextAccessor>();
var compilationSettings = GetCompilationSettings(compilerOptionsProvider, context.ProjectContext);
var fileProvider = new PhysicalFileProvider(context.ProjectContext.ProjectDirectory);
var viewCompiler = new RazorPreCompiler(
context,
loadContextAccessor,
fileProvider,
_memoryCache,
compilationSettings)
{
GenerateSymbols = GenerateSymbols
};
viewCompiler.CompileViews();
}
protected virtual IReadOnlyList <RazorFileInfo> CreateCompilationDescriptors(
[NotNull] IBeforeCompileContext context)
{
var options = SyntaxTreeGenerator.GetParseOptions(context.CSharpCompilation);
var list = new List <RazorFileInfo>();
foreach (var info in GetFileInfosRecursive(string.Empty))
{
var descriptor = ParseView(info,
context,
options);
if (descriptor != null)
{
list.Add(descriptor);
}
}
return(list);
}
protected virtual RazorFileInfo ParseView([NotNull] RelativeFileInfo fileInfo,
[NotNull] IBeforeCompileContext context,
[NotNull] CSharpParseOptions options)
{
using (var stream = fileInfo.FileInfo.CreateReadStream())
{
var results = _host.GenerateCode(fileInfo.RelativePath, stream);
foreach (var parserError in results.ParserErrors)
{
var diagnostic = parserError.ToDiagnostics(fileInfo.FileInfo.PhysicalPath);
context.Diagnostics.Add(diagnostic);
}
var generatedCode = results.GeneratedCode;
if (generatedCode != null)
{
var syntaxTree = SyntaxTreeGenerator.Generate(generatedCode, fileInfo.FileInfo.PhysicalPath, options);
var fullTypeName = results.GetMainClassName(_host, syntaxTree);
if (fullTypeName != null)
{
context.CSharpCompilation = context.CSharpCompilation.AddSyntaxTrees(syntaxTree);
var hash = RazorFileHash.GetHash(fileInfo.FileInfo);
return(new RazorFileInfo()
{
FullTypeName = fullTypeName,
RelativePath = fileInfo.RelativePath,
LastModified = fileInfo.FileInfo.LastModified,
Length = fileInfo.FileInfo.Length,
Hash = hash,
});
}
}
}
return(null);
}
public void BeforeCompile(IBeforeCompileContext context)
{
// Find all the class containers we care about.
var containers = context.CSharpCompilation.SyntaxTrees
.Select(tree => new
{
Model = context.CSharpCompilation.GetSemanticModel(tree),
SyntaxTree = tree,
Root = tree.GetRoot()
});
var addAssemblyMethodCalls = containers
.SelectMany(ctx => GetAddAssemblyMethodCall(ctx.SyntaxTree, ctx.Model));
// Build the registration statements out of the containers.
var nodes = GetStatements(context, containers.SelectMany(ctx => GetClassesWithImplementationAttribute(ctx.SyntaxTree, ctx.Model)))
.ToArray();
var newCompilation = context.CSharpCompilation;
foreach (var method in addAssemblyMethodCalls)
{
var identifierName = ((MemberAccessExpressionSyntax)method.Declaration.Expression).Expression.ToString();
var methodNodes = nodes.SelectMany(x => x(identifierName));
var oldSyntaxRoot = method.Declaration.SyntaxTree.GetRoot();
var newSyntaxRoot = oldSyntaxRoot
.ReplaceNode(method.Declaration.Parent, methodNodes)
.NormalizeWhitespace();
var oldSyntaxTree = method.Declaration.SyntaxTree;
var newSyntaxTree = oldSyntaxTree.WithRootAndOptions(newSyntaxRoot, oldSyntaxTree.Options);
newCompilation = newCompilation.ReplaceSyntaxTree(oldSyntaxTree, newSyntaxTree);
}
context.CSharpCompilation = newCompilation;
}
public void BeforeCompile(IBeforeCompileContext context)
{
//Debugger.Launch();
var project = ((CompilationContext)(context)).Project;
var settings = LoadSettings(project);
// HACK to make project available to default view
_defaultRazorViewLocator.ProjectDelegate = () => project;
_defaultStaticFileLocator.ProjectDelegate = () => project;
// generate r4mvc syntaxtree
var generator = _serviceProvider.GetService<R4MvcGenerator>();
var generatedNode = generator.Generate((CompilationContext)context, settings);
// out to file
var generatedFilePath = Path.Combine(project.ProjectDirectory, R4MvcGenerator.R4MvcFileName);
generatedNode.WriteFile(generatedFilePath);
// update compilation
context.Compilation.AddSyntaxTrees(generatedNode.SyntaxTree);
}
public void BeforeCompile(IBeforeCompileContext context)
{
//Debugger.Launch();
var project = ((CompilationContext)(context)).Project;
var settings = LoadSettings(project);
// HACK to make project available to default view
_defaultRazorViewLocator.ProjectDelegate = () => project;
_defaultStaticFileLocator.ProjectDelegate = () => project;
// generate r4mvc syntaxtree
var generator = _serviceProvider.GetService <R4MvcGenerator>();
var generatedNode = generator.Generate((CompilationContext)context, settings);
// out to file
var generatedFilePath = Path.Combine(project.ProjectDirectory, R4MvcGenerator.R4MvcFileName);
generatedNode.WriteFile(generatedFilePath);
// update compilation
context.Compilation.AddSyntaxTrees(generatedNode.SyntaxTree);
}
public void BeforeCompile(IBeforeCompileContext context)
{
}
public Func <string, IEnumerable <StatementSyntax> > GetStatement(IBeforeCompileContext context, INamedTypeSymbol symbol, ClassDeclarationSyntax declaration)
{
var attributeSymbol = symbol.GetAttributes().Single(x => x.AttributeClass.Name.ToString().Contains("ServiceDescriptorAttribute"));
var attributeDeclaration = declaration.AttributeLists
.SelectMany(z => z.Attributes)
.Single(z => z.Name.ToString().Contains("ServiceDescriptor"));
var implementationType = symbol.ConstructUnboundGenericType().ToDisplayString();
var implementationQualifiedName = BuildQualifiedName(implementationType, symbol.TypeParameters.Count());
string serviceType = null;
IEnumerable <NameSyntax> serviceQualifiedNames = symbol.AllInterfaces
.Select(z => BuildQualifiedName(z.ConstructUnboundGenericType().ToDisplayString(), z.TypeParameters.Count()));
if (declaration.Modifiers.Any(z => z.RawKind == (int)SyntaxKind.PublicKeyword))
{
// TODO: Should this include all base types? Should it be the lowest base type (HttpContext for example)?
serviceQualifiedNames = serviceQualifiedNames.Union(new NameSyntax[] { implementationQualifiedName });
}
if (attributeSymbol.ConstructorArguments.Count() > 0 && attributeSymbol.ConstructorArguments[0].Value != null)
{
var serviceNameTypedSymbol = (INamedTypeSymbol)attributeSymbol.ConstructorArguments[0].Value;
if (serviceNameTypedSymbol == null)
{
throw new Exception("Could not infer service symbol");
}
serviceType = serviceNameTypedSymbol.ConstructUnboundGenericType().ToString();
serviceQualifiedNames = new NameSyntax[] { BuildQualifiedName(serviceType, serviceNameTypedSymbol.TypeParameters.Count()) };
}
var baseTypes = new List <string>();
var impType = symbol;
while (impType != null)
{
baseTypes.Add(impType.ToDisplayString());
impType = impType.BaseType;
}
// TODO: Enforce implementation is assignable to service
// Diagnostic error?
var potentialBaseTypes = baseTypes.Concat(
symbol.AllInterfaces.Select(z => z.ConstructUnboundGenericType().ToDisplayString())
);
// This is where some of the power comes out.
// We now have the ability to throw compile time errors if we believe something is wrong.
// This could be extended to support generic types, and potentially matching compatible open generic types together to build a list.
if (serviceType != null && !potentialBaseTypes.Any(z => serviceType.Equals(z, StringComparison.OrdinalIgnoreCase)))
{
var serviceName = serviceType.Split('.').Last();
var implementationName = implementationType.Split('.').Last();
context.Diagnostics.Add(
Diagnostic.Create(
new DiagnosticDescriptor(
"DI0001",
"Implementation miss-match",
"The implementation '{0}' does not implement the service '{1}'",
"DependencyInjection",
DiagnosticSeverity.Error,
true
),
Location.Create(attributeDeclaration.SyntaxTree, attributeDeclaration.Span),
implementationName,
serviceName
)
);
}
var hasLifecycle = attributeSymbol.NamedArguments.Any(z => z.Key == "Lifecycle");
var lifecycle = "Transient";
if (hasLifecycle)
{
lifecycle = GetLifecycle((int)attributeSymbol.NamedArguments.Single(z => z.Key == "Lifecycle").Value.Value);
}
// Build the Statement
return(GetCollectionExpressionStatement(lifecycle, serviceQualifiedNames, implementationQualifiedName));
}
public IEnumerable <Func <string, IEnumerable <StatementSyntax> > > GetStatements(IBeforeCompileContext context, IEnumerable <Container <ClassDeclarationSyntax, INamedTypeSymbol> > containers)
{
foreach (var container in containers)
{
yield return(GetStatement(context, container.Symbol, container.Declaration));
}
}
public void BeforeCompile(IBeforeCompileContext context)
{
var candidates = new List<string>();
candidates.Add(Path.Combine(context.ProjectContext.ProjectDirectory, "..", "..", "submodules"));
if (context.ProjectContext.Name != "Microsoft.Framework.Runtime")
{
candidates.Add(Path.Combine(context.ProjectContext.ProjectDirectory, "..", "Microsoft.Framework.Runtime.Hosting"));
}
var submodulesDir = Path.Combine(context.ProjectContext.ProjectDirectory, "..", "..", "submodules");
var replacementDict = new Dictionary<SyntaxTree, SyntaxTree>();
var removeList = new List<SyntaxTree>();
foreach (var tree in context.Compilation.SyntaxTrees)
{
if (string.IsNullOrEmpty(tree.FilePath) ||
!candidates.Any(c => IsChildOfDirectory(dir: c, candidate: tree.FilePath)))
{
continue;
}
if (string.Equals("AssemblyInfo.cs", Path.GetFileName(tree.FilePath),
StringComparison.OrdinalIgnoreCase))
{
removeList.Add(tree);
continue;
}
var root = tree.GetRoot();
var targetSyntaxKinds = new[] {
SyntaxKind.ClassDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.EnumDeclaration
};
var typeDeclarations = root.DescendantNodes()
.Where(x => targetSyntaxKinds.Contains(x.Kind()))
.OfType<BaseTypeDeclarationSyntax>();
var publicKeywordTokens = new List<SyntaxToken>();
foreach (var declaration in typeDeclarations)
{
var publicKeywordToken = declaration.Modifiers
.SingleOrDefault(x => x.Kind() == SyntaxKind.PublicKeyword);
if (publicKeywordToken != default(SyntaxToken))
{
publicKeywordTokens.Add(publicKeywordToken);
}
}
if (publicKeywordTokens.Any())
{
root = root.ReplaceTokens(publicKeywordTokens,
(_, oldToken) => SyntaxFactory.ParseToken("internal").WithTriviaFrom(oldToken));
}
replacementDict.Add(tree,
SyntaxFactory.SyntaxTree(root, tree.Options, tree.FilePath, tree.GetText().Encoding));
}
context.Compilation = context.Compilation.RemoveSyntaxTrees(removeList);
foreach (var pair in replacementDict)
{
context.Compilation = context.Compilation.ReplaceSyntaxTree(pair.Key, pair.Value);
}
}
public void BeforeCompile(IBeforeCompileContext context)
{
var candidates = new List <string>();
candidates.Add(Path.Combine(context.ProjectContext.ProjectDirectory, "..", "..", "submodules"));
if (context.ProjectContext.Name != "Microsoft.Framework.Runtime")
{
candidates.Add(Path.Combine(context.ProjectContext.ProjectDirectory, "..", "Microsoft.Framework.Runtime.Hosting"));
}
var submodulesDir = Path.Combine(context.ProjectContext.ProjectDirectory, "..", "..", "submodules");
var replacementDict = new Dictionary <SyntaxTree, SyntaxTree>();
var removeList = new List <SyntaxTree>();
foreach (var tree in context.Compilation.SyntaxTrees)
{
if (string.IsNullOrEmpty(tree.FilePath) ||
!candidates.Any(c => IsChildOfDirectory(dir: c, candidate: tree.FilePath)))
{
continue;
}
if (string.Equals("AssemblyInfo.cs", Path.GetFileName(tree.FilePath),
StringComparison.OrdinalIgnoreCase))
{
removeList.Add(tree);
continue;
}
var root = tree.GetRoot();
var targetSyntaxKinds = new[] {
SyntaxKind.ClassDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.EnumDeclaration
};
var typeDeclarations = root.DescendantNodes()
.Where(x => targetSyntaxKinds.Contains(x.Kind()))
.OfType <BaseTypeDeclarationSyntax>();
var publicKeywordTokens = new List <SyntaxToken>();
foreach (var declaration in typeDeclarations)
{
var publicKeywordToken = declaration.Modifiers
.SingleOrDefault(x => x.Kind() == SyntaxKind.PublicKeyword);
if (publicKeywordToken != default(SyntaxToken))
{
publicKeywordTokens.Add(publicKeywordToken);
}
}
if (publicKeywordTokens.Any())
{
root = root.ReplaceTokens(publicKeywordTokens,
(_, oldToken) => SyntaxFactory.ParseToken("internal").WithTriviaFrom(oldToken));
}
replacementDict.Add(tree,
SyntaxFactory.SyntaxTree(root, tree.Options, tree.FilePath, tree.GetText().Encoding));
}
context.Compilation = context.Compilation.RemoveSyntaxTrees(removeList);
foreach (var pair in replacementDict)
{
context.Compilation = context.Compilation.ReplaceSyntaxTree(pair.Key, pair.Value);
}
}
/// <summary>
/// Initializes a new instance of <see cref="PrecompilationTagHelperTypeResolver"/>.
/// </summary>
/// <param name="compileContext">The <see cref="IBeforeCompileContext"/>.</param>
/// <param name="loadContext">The <see cref="IAssemblyLoadContext"/>.</param>
public PrecompilationTagHelperTypeResolver([NotNull] IBeforeCompileContext compileContext,
[NotNull] IAssemblyLoadContext loadContext)
{
_compileContext = compileContext;
_loadContext = loadContext;
}
/// <summary>
/// Initializes a new instance of <see cref="PrecompilationTagHelperTypeResolver"/>.
/// </summary>
/// <param name="compileContext">The <see cref="IBeforeCompileContext"/>.</param>
/// <param name="loadContext">The <see cref="IAssemblyLoadContext"/>.</param>
public PrecompilationTagHelperTypeResolver([NotNull] IBeforeCompileContext compileContext,
[NotNull] IAssemblyLoadContext loadContext)
{
_compileContext = compileContext;
_loadContext = loadContext;
}
