Add logging

SlowLogicBoy · SlowLogicBoy · commit 15cb326c81c5 · 2018-03-20T09:34:45.000+02:00
diff --git a/src/Dotnet.Script.Core/ScriptCompiler.cs b/src/Dotnet.Script.Core/ScriptCompiler.cs
@@ -80,12 +80,12 @@ public virtual ScriptOptions CreateScriptOptions(ScriptContext context, IList<Ru
                 .WithMetadataResolver(new NuGetMetadataReferenceResolver(ScriptMetadataResolver.Default.WithBaseDirectory(context.WorkingDirectory)))
                 .WithEmitDebugInformation(true)
                 .WithFileEncoding(context.Code.Encoding);
-            
+
             if (!string.IsNullOrWhiteSpace(context.FilePath))
             {
                 opts = opts.WithFilePath(context.FilePath);
             }
-            
+
             return opts;
         }
 
@@ -110,7 +110,7 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur
                 .ToDictionary(f => f.Name, f => f.ResolvedRuntimeAssembly, StringComparer.OrdinalIgnoreCase);
 
             foreach (var runtimeAssembly in dependencyMap.Values)
-            {                                
+            {
                 Logger.Verbose("Adding reference to a runtime dependency => " + runtimeAssembly);
                 opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeAssembly.Path));
             }
@@ -126,15 +126,15 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur
             foreach (var inheritedAssemblyName in inheritedAssemblyNames)
             {
                 // Always prefer the resolved runtime dependency rather than the inherited assembly.
-                if(!dependencyMap.ContainsKey(inheritedAssemblyName.Name))                
+                if(!dependencyMap.ContainsKey(inheritedAssemblyName.Name))
                 {
                     Logger.Verbose($"Adding reference to an inherited dependency => {inheritedAssemblyName.FullName}");
                     var assembly = Assembly.Load(inheritedAssemblyName);
-                    opts = opts.AddReferences(assembly);                    
+                    opts = opts.AddReferences(assembly);
                 }
             }
 
-            AppDomain.CurrentDomain.AssemblyResolve += 
+            AppDomain.CurrentDomain.AssemblyResolve +=
                 (sender, args) => MapUnresolvedAssemblyToRuntimeLibrary(dependencyMap, args);
 
             // when processing raw code, make sure we inject new lines after preprocessor directives
@@ -156,7 +156,7 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur
 
             if (context.OptimizationLevel == OptimizationLevel.Release)
             {
-                Logger.Verbose("Configuration/Optimization mode: Release");                
+                Logger.Verbose("Configuration/Optimization mode: Release");
                 SetReleaseOptimizationLevel(script.GetCompilation());
             }
             else
@@ -176,13 +176,13 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur
         }
 
         private static void SetReleaseOptimizationLevel(Compilation compilation)
-        {            
+        {
             var compilationOptionsField = typeof(CSharpCompilation).GetTypeInfo().GetDeclaredField("_options");
             var compilationOptions = (CSharpCompilationOptions)compilationOptionsField.GetValue(compilation);
             compilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Release);
-            compilationOptionsField.SetValue(compilation, compilationOptions);        
+            compilationOptionsField.SetValue(compilation, compilationOptions);
         }
-        
+
         private Assembly MapUnresolvedAssemblyToRuntimeLibrary(IDictionary<string, RuntimeAssembly> dependencyMap, ResolveEventArgs args)
         {
             var assemblyName = new AssemblyName(args.Name);
@@ -192,9 +192,12 @@ private Assembly MapUnresolvedAssemblyToRuntimeLibrary(IDictionary<string, Runti
                 {
                     var loadedAssembly = AppDomain.CurrentDomain.GetAssemblies()
                         .FirstOrDefault(a => a.GetName().Name == assemblyName.Name);
-                    if(loadedAssembly != null) 
+                    if(loadedAssembly != null)
+                    {
+                        Logger.Log($"Redirecting {assemblyName} to already loaded {loadedAssembly.GetName().Name}");
                         return loadedAssembly;
-                    Logger.Log($"Redirecting {assemblyName} to {runtimeAssembly.Name}");                 
+                    }
+                    Logger.Log($"Redirecting {assemblyName} to {runtimeAssembly.Name}");
                     return Assembly.LoadFrom(runtimeAssembly.Path);
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -80,12 +80,12 @@ public virtual ScriptOptions CreateScriptOptions(ScriptContext context, IList<Ru`
`80`	`80`	`.WithMetadataResolver(new NuGetMetadataReferenceResolver(ScriptMetadataResolver.Default.WithBaseDirectory(context.WorkingDirectory)))`
`81`	`81`	`.WithEmitDebugInformation(true)`
`82`	`82`	`.WithFileEncoding(context.Code.Encoding);`
`83`		`-`
	`83`	`+`
`84`	`84`	`if (!string.IsNullOrWhiteSpace(context.FilePath))`
`85`	`85`	`{`
`86`	`86`	`opts = opts.WithFilePath(context.FilePath);`
`87`	`87`	`}`
`88`		`-`
	`88`	`+`
`89`	`89`	`return opts;`
`90`	`90`	`}`
`91`	`91`
`@@ -110,7 +110,7 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur`
`110`	`110`	`.ToDictionary(f => f.Name, f => f.ResolvedRuntimeAssembly, StringComparer.OrdinalIgnoreCase);`
`111`	`111`
`112`	`112`	`foreach (var runtimeAssembly in dependencyMap.Values)`
`113`		`- {`
	`113`	`+ {`
`114`	`114`	`Logger.Verbose("Adding reference to a runtime dependency => " + runtimeAssembly);`
`115`	`115`	`opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeAssembly.Path));`
`116`	`116`	`}`
`@@ -126,15 +126,15 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur`
`126`	`126`	`foreach (var inheritedAssemblyName in inheritedAssemblyNames)`
`127`	`127`	`{`
`128`	`128`	`// Always prefer the resolved runtime dependency rather than the inherited assembly.`
`129`		`- if(!dependencyMap.ContainsKey(inheritedAssemblyName.Name))`
	`129`	`+ if(!dependencyMap.ContainsKey(inheritedAssemblyName.Name))`
`130`	`130`	`{`
`131`	`131`	`Logger.Verbose($"Adding reference to an inherited dependency => {inheritedAssemblyName.FullName}");`
`132`	`132`	`var assembly = Assembly.Load(inheritedAssemblyName);`
`133`		`- opts = opts.AddReferences(assembly);`
	`133`	`+ opts = opts.AddReferences(assembly);`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
`137`		`- AppDomain.CurrentDomain.AssemblyResolve +=`
	`137`	`+ AppDomain.CurrentDomain.AssemblyResolve +=`
`138`	`138`	`(sender, args) => MapUnresolvedAssemblyToRuntimeLibrary(dependencyMap, args);`
`139`	`139`
`140`	`140`	`// when processing raw code, make sure we inject new lines after preprocessor directives`
`@@ -156,7 +156,7 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur`
`156`	`156`
`157`	`157`	`if (context.OptimizationLevel == OptimizationLevel.Release)`
`158`	`158`	`{`
`159`		`- Logger.Verbose("Configuration/Optimization mode: Release");`
	`159`	`+ Logger.Verbose("Configuration/Optimization mode: Release");`
`160`	`160`	`SetReleaseOptimizationLevel(script.GetCompilation());`
`161`	`161`	`}`
`162`	`162`	`else`
`@@ -176,13 +176,13 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`private static void SetReleaseOptimizationLevel(Compilation compilation)`
`179`		`- {`
	`179`	`+ {`
`180`	`180`	`var compilationOptionsField = typeof(CSharpCompilation).GetTypeInfo().GetDeclaredField("_options");`
`181`	`181`	`var compilationOptions = (CSharpCompilationOptions)compilationOptionsField.GetValue(compilation);`
`182`	`182`	`compilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Release);`
`183`		`- compilationOptionsField.SetValue(compilation, compilationOptions);`
	`183`	`+ compilationOptionsField.SetValue(compilation, compilationOptions);`
`184`	`184`	`}`
`185`		`-`
	`185`	`+`
`186`	`186`	`private Assembly MapUnresolvedAssemblyToRuntimeLibrary(IDictionary<string, RuntimeAssembly> dependencyMap, ResolveEventArgs args)`
`187`	`187`	`{`
`188`	`188`	`var assemblyName = new AssemblyName(args.Name);`
`@@ -192,9 +192,12 @@ private Assembly MapUnresolvedAssemblyToRuntimeLibrary(IDictionary<string, Runti`
`192`	`192`	`{`
`193`	`193`	`var loadedAssembly = AppDomain.CurrentDomain.GetAssemblies()`
`194`	`194`	`.FirstOrDefault(a => a.GetName().Name == assemblyName.Name);`
`195`		`- if(loadedAssembly != null)`
	`195`	`+ if(loadedAssembly != null)`
	`196`	`+ {`
	`197`	`+ Logger.Log($"Redirecting {assemblyName} to already loaded {loadedAssembly.GetName().Name}");`
`196`	`198`	`return loadedAssembly;`
`197`		`- Logger.Log($"Redirecting {assemblyName} to {runtimeAssembly.Name}");`
	`199`	`+ }`
	`200`	`+ Logger.Log($"Redirecting {assemblyName} to {runtimeAssembly.Name}");`
`198`	`201`	`return Assembly.LoadFrom(runtimeAssembly.Path);`
`199`	`202`	`}`
`200`	`203`	`}`