/// <summary> /// Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved. /// </summary> internal List <MetadataReference> ResolveMetadataReferences( MetadataFileReferenceResolver externalReferenceResolver, MetadataFileReferenceProvider metadataProvider, List <DiagnosticInfo> diagnostics, AssemblyIdentityComparer assemblyIdentityComparer, TouchedFileLogger touchedFiles, out MetadataFileReferenceResolver referenceDirectiveResolver) { List <MetadataReference> resolved = new List <MetadataReference>(); Arguments.ResolveMetadataReferences(new AssemblyReferenceResolver(externalReferenceResolver, metadataProvider), diagnostics, this.MessageProvider, resolved); if (Arguments.IsInteractive) { referenceDirectiveResolver = externalReferenceResolver; } else { // when compiling into an assembly (csc/vbc) we only allow #r that match references given on command line: referenceDirectiveResolver = new ExistingReferencesResolver( resolved.Where(r => r.Properties.Kind == MetadataImageKind.Assembly).OfType <PortableExecutableReference>().AsImmutable(), Arguments.ReferencePaths, Arguments.BaseDirectory, assemblyIdentityComparer, touchedFiles); } return(resolved); }
public void Run() { Solution sln = LoadSolution(); //var externalProject = sln.Projects.FirstOrDefault(x => x.AssemblyName == externalNs); //if (externalProject == null) //{ // var msg = string.Format("Project for given external-facing namespace of {0} not found.", externalNs); // messagePump.OnError(new ArgumentException(msg)); // return; //} SendMessage(string.Format("{1}Using {0} for process discovery{1}", processTypeName ?? DefaultProcessIfxName, Environment.NewLine)); var token = new CancellationToken(); var analyzer = new MIL.Services.ProcessAnalysisService(processIName); //ProcessDefinition processDefinition = null; var excludeList = sln.Projects.Where(x => ExcludedAssemblies.Any(e => x.AssemblyName.Contains(e))).ToList(); if (excludeList.Any()) { SendMessage(string.Format("Ignoring {0} Assemblies{1}", excludeList.Count, Environment.NewLine), () => "Ignored assemblies: " + Environment.NewLine + string.Join(Environment.NewLine, excludeList.Select(x => x.AssemblyName)) + Environment.NewLine); } MilSyntaxWalker treeData = new MilSyntaxWalker(); foreach (var proj in sln.Projects.Except(excludeList)) { SendMessage(".", () => Environment.NewLine + "# Processing assembly " + proj.AssemblyName + Environment.NewLine); MilSemanticAnalyzer semantics = null; MetadataFileReferenceProvider provider = new MetadataFileReferenceProvider(); Compilation compilation = (Compilation)proj.GetCompilationAsync(token).Result .AddReferences(new MetadataFileReference(typeof(object).Assembly.Location)) .AddReferences(new MetadataFileReference(typeof(IEnumerable<>).Assembly.Location)); ; try { semantics = new MilSemanticAnalyzer(compilation); } catch (InvalidOperationException ex) { SendMessage("x", () => string.Join(Environment.NewLine, compilation.GetDeclarationDiagnostics().Select(x => x.ToString())) + Environment.NewLine); continue; } semantics.ExtractMessagingSyntax(treeData); //if (proj.AssemblyName == externalProject.AssemblyName) // continue; //processDefinition = analyzer.GetProcessDefinition(compilation, processTypeName); //if (processDefinition != null) //{ // var procToke = ProcessDefinition.GetTokenFromDefinition(processDefinition); // if (procToke.Token != MilTypeConstant.EmptyToken) // SendMessage(procToke.ToString()); //} //foreach (var pubCall in semantics.GetMessagePublicationData()) //{ // SendMessage(pubCall.ToString()); //} } DumpSyntaxData(treeData); messagePump.OnCompleted(); }
public CSharpScriptEngine(MetadataFileReferenceProvider metadataReferenceProvider = null) : base(metadataReferenceProvider) { }
/// <summary> /// Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved. /// </summary> internal List<MetadataReference> ResolveMetadataReferences( MetadataFileReferenceResolver externalReferenceResolver, MetadataFileReferenceProvider metadataProvider, List<DiagnosticInfo> diagnostics, AssemblyIdentityComparer assemblyIdentityComparer, TouchedFileLogger touchedFiles, out MetadataFileReferenceResolver referenceDirectiveResolver) { List<MetadataReference> resolved = new List<MetadataReference>(); Arguments.ResolveMetadataReferences(new AssemblyReferenceResolver(externalReferenceResolver, metadataProvider), diagnostics, this.MessageProvider, resolved); if (Arguments.IsInteractive) { referenceDirectiveResolver = externalReferenceResolver; } else { // when compiling into an assembly (csc/vbc) we only allow #r that match references given on command line: referenceDirectiveResolver = new ExistingReferencesResolver( CreateLoggingMetadataResolver(touchedFiles), resolved.Where(r => r.Properties.Kind == MetadataImageKind.Assembly).OfType<PortableExecutableReference>().AsImmutable(), assemblyIdentityComparer); } return resolved; }
public AssemblyReferenceResolver(MetadataFileReferenceResolver pathResolver, MetadataFileReferenceProvider provider) { Debug.Assert(pathResolver != null && provider != null); this.PathResolver = pathResolver; this.Provider = provider; }
public CSharpScriptEngine(MetadataFileReferenceProvider metadataReferenceProvider = null, AssemblyLoader assemblyLoader = null) : base(metadataReferenceProvider, assemblyLoader) { }
/// <summary> /// Creates a new <see cref="ScriptOptions"/> with the reference provider specified. /// </summary> internal ScriptOptions WithReferenceProvider(MetadataFileReferenceProvider provider) { if (provider == _referenceResolver.Provider) { return this; } return With(resolver: new AssemblyReferenceResolver(_referenceResolver.PathResolver, provider)); }