private void performAnalysis(CompilationAnalysis analysis_, Compilation compilation)
{
if (analysis_ == null)
{
return;
}
var analysis = (CompilationAnalysisBase <SyntaxToken, SyntaxNode, SemanticModel>)analysis_;
if (!analysis.isNeeded())
{
return;
}
foreach (var document in _documents)
{
var root = document.Document.SyntaxRoot;
if (root != null)
{
var model = _compilation.GetSemanticModel(root.SyntaxTree); //td: really neccesary?
var visitor = new CompilationAnalysisVisitor(analysis, compilation, _scope);
visitor.Visit(root);
}
}
analysis.Finish(compilation, compilation.Scope);
}
public SolutionCompilation(string solution, CompilationAnalysis analysis, IDictionary <string, ExtensionFunc> extensions)
{
_extensions = extensions;
_analysis = analysis;
_solution = solution;
_workspace = MSBuildWorkspace.Create();
}
private static Compilation createCompilation(string text,
List <Diagnostic> errors = null,
IPersistentStorage storage = null,
CompilationAnalysis analysis = null)
{
var injector = new CompositeInjector <SyntaxToken, SyntaxNode, SemanticModel>(new[]
{
new DelegateInjector <SyntaxToken, SyntaxNode, SemanticModel>(compiler => compiler
.Environment()
.dependency <ExcessOwinMiddleware>("Excess.Server.Middleware")
.dependency <IAppBuilder>("Owin")
.dependency <IOwinRequest>("Microsoft.Owin")
.dependency <__Scope>("Excess.Runtime")),
new DelegateInjector <SyntaxToken, SyntaxNode, SemanticModel>(
compiler => ConcurrentExtension.Apply((RoslynCompiler)compiler)),
new DelegateInjector <SyntaxToken, SyntaxNode, SemanticModel>(
compiler => ServerExtension.Apply(compiler, new Scope(null))),
new DelegateInjector <SyntaxToken, SyntaxNode, SemanticModel>(
compiler => Functions.Apply(compiler))
});
if (analysis != null)
{
ServerExtension.Compilation(analysis);
}
var compilation = new Compilation(storage, analysis: analysis);
compilation.addDocument("test", text, injector);
return(compilation);
}
public static void Compilation(CompilationAnalysis compilation)
{
compilation
.match <ClassDeclarationSyntax>(isService)
.then(jsService)
.match <ClassDeclarationSyntax>(isConcurrentClass)
.then(jsConcurrentClass)
.after(addJSFiles);
}
public RoslynCompilation(
IPersistentStorage storage = null,
CompilationAnalysis analysis = null,
IDictionary <string, LoaderFunc> extensions = null,
bool executable = false)
{
_environment = createEnvironment(storage);
_analysis = analysis;
_extensions = extensions;
_executable = executable;
//setup
_scope.set <ICompilerEnvironment>(_environment);
_scope.set <ICompilerService <SyntaxToken, SyntaxNode, SemanticModel> >(new CompilerService());
}
public static void AppCompilation(CompilationAnalysis compilation)
{
//app support
var Programs = new List <ClassDeclarationSyntax>();
var Singletons = new List <ClassDeclarationSyntax>();
compilation
.match <ClassDeclarationSyntax>((@class, model, scpe) =>
@class.Identifier.ToString() == "Program" &&
@class
.Members
.OfType <MethodDeclarationSyntax>()
.Any(method => method.Identifier.ToString() == "Main"))
.then((node, model, scpe) => Programs.Add((ClassDeclarationSyntax)node))
.match <ClassDeclarationSyntax>((@class, model, scpe) => isSingleton(@class))
.then((node, model, scpe) => Singletons.Add((ClassDeclarationSyntax)node))
.after(AddAppProgram(Programs, Singletons));
}
public static void Apply(ExcessCompiler compiler, Scope scope, CompilationAnalysis compilation = null)
{
var options = scope?.get <ServerExtensionOptions>()
?? new ServerExtensionOptions();
var keywords = scope?.get("keywords") as List <string>;
keywords?.Add("service");
//compiler.Syntax()
// .extension("server", ExtensionKind.Type, CompileServer);
var lexical = compiler.Lexical();
lexical.match()
.token("service", named: "keyword")
.identifier(named: "ref")
.then(lexical.transform()
.replace("keyword", "class ")
.then(CompileService));
compiler.Environment()
.dependency("System.Configuration")
.dependency("System.Security.Principal")
.dependency("Microsoft.Owin")
.dependency("Excess.Server.Middleware")
;
compiler.Lexical()
.indented <ServerModel, ServerInstance>("server", ExtensionKind.Type, InitApp)
.match <ServerModel, ServerInstance, ServerLocation>(new[] {
"@{Url}",
"on port {Port}",
"@{Url} port {Port}",
"@{Url}, port {Port}"
},
then: SetServerLocation)
.match <ServerModel, ServerInstance, ConfigModel>("using {Threads} threads", then: SetConfiguration)
.match <ServerModel, ServerInstance, ConfigModel>("identity @{Identity}", then: SetConfiguration)
.match <ServerModel, ServerInstance, HostingModel>("hosting {ClassName}",
then: (server, hosting) => server.HostedClasses.Add(hosting.ClassName))
.match <ServerModel, ServerInstance, StaticFilesModel>(new[] {
"static files @{Directory}",
"static files {Directory}",
},
then: (server, staticFiles) => server.StaticFiles = staticFiles.Directory)
.match <ServerModel, ServerInstance, ServerInstance>("new instance",
then: AddInstance,
children: child => child.match_parent())
.match <ServerModel, ServerInstance, SQLLocation>(new[] {
"sql @{ConnectionString}",
"sql with {ConnectionInstantiator} @{ConnectionString}",
"sql on connection {ConnectionId}",
"sql with {ConnectionInstantiator} on connection {ConnectionId}",
},
then: (server, sql) => server.SetSqlLocation(sql))
.then()
.transform <ServerInstance>(LinkServerInstance);
}
public static void ConsoleCompilation(CompilationAnalysis compilation) => ConcurrentExtension.AppCompilation(compilation);
public static void PerformanceCompilation(CompilationAnalysis compilation) => ConcurrentExtension.AppCompilation(compilation);
public CompilationAnalysisVisitor(CompilationAnalysis analysis, Compilation compilation, Scope scope)
{
_analysis = analysis;
_compilation = compilation;
_scope = scope;
}
