/// <summary>
/// Gets the references that need to be assigned to the compilation.
/// This can be different than the list of references defined by the <see cref="ScriptOptions"/> instance.
/// </summary>
internal ImmutableArray <MetadataReference> GetReferencesForCompilation()
{
var references = Options.References;
var previous = Previous;
if (previous != null)
{
// TODO (tomat): RESOLVED? bound imports should be reused from previous submission instead of passing
// them to every submission in the chain. See bug #7802.
var compilation = previous.GetCompilation();
return(ImmutableArray.CreateRange(references.Union(compilation.References)));
}
var corLib = MetadataReference.CreateFromAssemblyInternal(typeof(object).GetTypeInfo().Assembly);
references = references.Add(corLib);
if (GlobalsType != null)
{
var globalsTypeAssembly = MetadataReference.CreateFromAssemblyInternal(GlobalsType.GetTypeInfo().Assembly);
references = references.Add(globalsTypeAssembly);
}
return(references);
}
public void CreateFrom_Errors()
{
Assert.Throws <ArgumentNullException>(() => MetadataReference.CreateFromImage(null));
Assert.Throws <ArgumentNullException>(
() => MetadataReference.CreateFromImage(default(ImmutableArray <byte>))
);
Assert.Throws <ArgumentNullException>(() => MetadataReference.CreateFromFile(null));
Assert.Throws <ArgumentNullException>(
() => MetadataReference.CreateFromFile(null, default(MetadataReferenceProperties))
);
Assert.Throws <ArgumentNullException>(() => MetadataReference.CreateFromStream(null));
Assert.Throws <ArgumentNullException>(
() => MetadataReference.CreateFromAssemblyInternal(null)
);
Assert.Throws <ArgumentException>(
() =>
MetadataReference.CreateFromAssemblyInternal(
typeof(object).Assembly,
new MetadataReferenceProperties(MetadataImageKind.Module)
)
);
var dynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName {
Name = "Goo"
},
System.Reflection.Emit.AssemblyBuilderAccess.Run
);
Assert.Throws <NotSupportedException>(
() => MetadataReference.CreateFromAssemblyInternal(dynamicAssembly)
);
}
/// <summary>
/// Gets the references that need to be assigned to the compilation.
/// This can be different than the list of references defined by the <see cref="ScriptOptions"/> instance.
/// </summary>
protected ImmutableArray <MetadataReference> GetReferencesForCompilation()
{
var references = _options.References;
if (this.GlobalsType != null)
{
var globalsTypeAssembly = MetadataReference.CreateFromAssemblyInternal(this.GlobalsType.Assembly);
if (!references.Contains(globalsTypeAssembly))
{
references = references.Add(globalsTypeAssembly);
}
}
if (_previous == null)
{
return(references);
}
else
{
// TODO (tomat): RESOLVED? bound imports should be reused from previous submission instead of passing
// them to every submission in the chain. See bug #7802.
var compilation = _previous.GetCompilation();
return(ImmutableArray.CreateRange(references.Union(compilation.References)));
}
}
public void CreateFromAssembly()
{
var assembly = typeof(object).Assembly;
var r = (PortableExecutableReference)MetadataReference.CreateFromAssemblyInternal(
assembly
);
Assert.Equal(assembly.Location, r.FilePath);
Assert.Equal(assembly.Location, r.Display);
Assert.Equal(MetadataImageKind.Assembly, r.Properties.Kind);
Assert.False(r.Properties.EmbedInteropTypes);
Assert.True(r.Properties.Aliases.IsEmpty);
Assert.Same(DocumentationProvider.Default, r.DocumentationProvider);
var props = new MetadataReferenceProperties(
MetadataImageKind.Assembly,
ImmutableArray.Create("a", "b"),
embedInteropTypes: true,
hasRecursiveAliases: true
);
Assert.Equal(
props,
MetadataReference.CreateFromAssemblyInternal(assembly, props).Properties
);
}
private static MetadataReference CreateReferenceFromAssembly(Assembly assembly)
{
return(MetadataReference.CreateFromAssemblyInternal(
assembly,
s_assemblyReferenceProperties
));
}
public void HostObjectBinding_Diagnostics()
{
var submission = CreateSubmission("x",
new[] { MetadataReference.CreateFromAssemblyInternal(typeof(B2).GetTypeInfo().Assembly) },
hostObjectType: typeof(B2));
submission.VerifyDiagnostics();
}
private CSharpCompilation CreateSubmission(string code, CSharpParseOptions options, int expectedErrorCount = 0)
{
var submission = CSharpCompilation.CreateSubmission("sub",
references: new[] { MetadataReference.CreateFromAssemblyInternal(typeof(object).Assembly) },
syntaxTree: Parse(code, options: options));
Assert.Equal(expectedErrorCount, submission.GetDiagnostics(CompilationStage.Declare, true, CancellationToken.None).Count());
return(submission);
}
public void Submissions_EmitToPeStream()
{
var references = new[] { MetadataReference.CreateFromAssemblyInternal(typeof(object).Assembly) };
CSharpCompilation s0 = CSharpCompilation.CreateSubmission("s0", syntaxTree: SyntaxFactory.ParseSyntaxTree("int a = 1;", options: TestOptions.Interactive), references: references, returnType: typeof(object));
CSharpCompilation s11 = CSharpCompilation.CreateSubmission("s11", syntaxTree: SyntaxFactory.ParseSyntaxTree("a + 1", options: TestOptions.Interactive), previousSubmission: s0, references: references, returnType: typeof(object));
CSharpCompilation s12 = CSharpCompilation.CreateSubmission("s12", syntaxTree: SyntaxFactory.ParseSyntaxTree("a + 2", options: TestOptions.Interactive), previousSubmission: s0, references: references, returnType: typeof(object));
CompileAndVerify(s11);
CompileAndVerify(s12);
}
public void AddReferences()
{
var options = ScriptOptions.Default.
AddReferences(typeof(int).GetTypeInfo().Assembly).
AddReferences(typeof(int).GetTypeInfo().Assembly).
AddReferences(MetadataReference.CreateFromAssemblyInternal(typeof(int).GetTypeInfo().Assembly)).
AddReferences("System.Linq").
AddReferences("System.Linq");
Assert.Equal(5, options.References.Length);
}
public void AddReferences()
{
var options = ScriptOptions.Default.
AddReferences(typeof(int).GetTypeInfo().Assembly).
AddReferences(typeof(int).GetTypeInfo().Assembly).
AddReferences(MetadataReference.CreateFromAssemblyInternal(typeof(int).GetTypeInfo().Assembly)).
AddReferences("System.Linq").
AddReferences("System.Linq");
Assert.Equal(GacFileResolver.IsAvailable ? 5 : 30, options.MetadataReferences.Length);
}
public void TestWriteOnlyStream()
{
var tree = CSharpSyntaxTree.ParseText("class Program { static void Main() { } }");
var compilation = CSharpCompilation.Create("Program",
new[] { tree },
new[] { MetadataReference.CreateFromAssemblyInternal(typeof(object).Assembly) },
TestOptions.DebugExe.WithDeterministic(true));
var output = new WriteOnlyStream();
compilation.Emit(output);
}
public void Submissions_ExecutionOrder3()
{
var references = new[] { MetadataReference.CreateFromAssemblyInternal(typeof(object).Assembly) };
CSharpCompilation s0 = CSharpCompilation.CreateSubmission("s0.dll", syntaxTree: SyntaxFactory.ParseSyntaxTree("int a = \"x\";", options: TestOptions.Interactive), references: references, returnType: typeof(object));
Assert.Throws <InvalidOperationException>(() =>
{
CSharpCompilation.CreateSubmission("s11.dll", syntaxTree: SyntaxFactory.ParseSyntaxTree("a + 1", options: TestOptions.Interactive), previousSubmission: s0, references: references, returnType: typeof(object));
});
}
public void TestWriteOnlyStream()
{
var tree = CSharpSyntaxTree.ParseText("class Program { static void Main() { } }",
TestOptions.Regular.WithDeterministicFeature());
var compilation = CSharpCompilation.Create("Program",
new[] { tree },
new[] { MetadataReference.CreateFromAssemblyInternal(typeof(object).Assembly) },
new CSharpCompilationOptions(OutputKind.ConsoleApplication));
var output = new WriteOnlyStream();
compilation.Emit(output);
}
public void CreateFromAssembly()
{
var assembly = typeof(object).Assembly;
var r = (PortableExecutableReference)MetadataReference.CreateFromAssemblyInternal(assembly);
Assert.Equal(assembly.Location, r.FilePath);
Assert.Equal(assembly.Location, r.Display);
Assert.Equal(MetadataImageKind.Assembly, r.Properties.Kind);
Assert.False(r.Properties.EmbedInteropTypes);
Assert.True(r.Properties.Aliases.IsEmpty);
Assert.Same(DocumentationProvider.Default, r.DocumentationProvider);
}
public void VBBackingFields_DebuggerBrowsable()
{
string source =
@"
Imports System
Class C
Public WithEvents WE As C
Public Event E As Action
Public Property A As Integer
End Class
";
var compilation = VB.VisualBasicCompilation.Create(
"goo",
new[] { VB.VisualBasicSyntaxTree.ParseText(source) },
new[]
{
MetadataReference.CreateFromAssemblyInternal(
typeof(object).GetTypeInfo().Assembly
)
},
new VB.VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
optimizationLevel: OptimizationLevel.Debug
)
);
Assembly a;
using (var stream = new MemoryStream())
{
var result = compilation.Emit(stream);
a = Assembly.Load(stream.ToArray());
}
var c = a.GetType("C");
var obj = Activator.CreateInstance(c);
var str = s_formatter.FormatObject(obj, SeparateLinesOptions);
AssertMembers(str, "C", "A: 0", "WE: null");
var attrsA = c.GetField("_A", BindingFlags.Instance | BindingFlags.NonPublic)
.GetCustomAttributes(typeof(DebuggerBrowsableAttribute), true);
var attrsWE = c.GetField("_WE", BindingFlags.Instance | BindingFlags.NonPublic)
.GetCustomAttributes(typeof(DebuggerBrowsableAttribute), true);
var attrsE = c.GetField("EEvent", BindingFlags.Instance | BindingFlags.NonPublic)
.GetCustomAttributes(typeof(DebuggerBrowsableAttribute), true);
Assert.Equal(1, attrsA.Length);
Assert.Equal(1, attrsWE.Length);
Assert.Equal(1, attrsE.Length);
}
public void CreateFromAssembly_NoMetadata()
{
var dynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName {
Name = "A"
}, System.Reflection.Emit.AssemblyBuilderAccess.Run);
Assert.Throws <NotSupportedException>(() => MetadataReference.CreateFromAssemblyInternal(dynamicAssembly));
var inMemoryAssembly = Assembly.Load(TestResources.General.C1);
Assert.Equal("", inMemoryAssembly.Location);
Assert.Throws <NotSupportedException>(() => MetadataReference.CreateFromAssemblyInternal(inMemoryAssembly));
}
public void CreateFromAssembly_WithPropertiesAndDocumentation()
{
var doc = new TestDocumentationProvider();
var assembly = typeof(object).Assembly;
var r = (PortableExecutableReference)MetadataReference.CreateFromAssemblyInternal(assembly, new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("a", "b"), embedInteropTypes: true), documentation: doc);
Assert.Equal(assembly.Location, r.FilePath);
Assert.Equal(assembly.Location, r.Display);
Assert.Equal(MetadataImageKind.Assembly, r.Properties.Kind);
Assert.True(r.Properties.EmbedInteropTypes);
AssertEx.Equal(ImmutableArray.Create("a", "b"), r.Properties.Aliases);
Assert.Same(doc, r.DocumentationProvider);
}
public void HostObjectBinding_Diagnostics()
{
var submission = CSharpCompilation.CreateSubmission("foo",
syntaxTree: SyntaxFactory.ParseSyntaxTree("x", options: TestOptions.Interactive),
references: new[]
{
MscorlibRef,
MetadataReference.CreateFromAssemblyInternal(typeof(ScriptTests).Assembly)
},
hostObjectType: typeof(B));
submission.VerifyDiagnostics();
}
private static CompiledFile CompileLibrary(TempDirectory dir, string fileName, string assemblyName, string source, params MetadataReference[] references)
{
var file = dir.CreateFile(fileName);
var compilation = CreateCompilation(
new[] { source },
assemblyName: assemblyName,
references: references.Concat(new[] { MetadataReference.CreateFromAssemblyInternal(typeof(object).Assembly) }),
options: fileName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) ? TestOptions.ReleaseExe : TestOptions.ReleaseDll);
var image = compilation.EmitToArray();
file.WriteAllBytes(image);
return new CompiledFile { Path = file.Path, Image = image };
}
/// <summary>
/// Finds any plugin attributes defined on the compiling assembly and instantiates them.
/// </summary>
private bool InstantiatePlugins()
{
Compilation compilationWithRoslynRef;
var pluginBaseClass = Compilation.GetTypeByMetadataName(ICompilerPluginAttributeName);
// If we can't find the compiler plugin attribute defined in this assembly or its references,
// create a new compilation that includes a reference to Microsoft.CodeAnalysis.
// This allows assemblies using compiler plugins to not have references to Roslyn.
if (pluginBaseClass == null)
{
var currentAssembly = typeof(CompilerPluginExecutor).GetTypeInfo().Assembly;
var mdRef = MetadataReference.CreateFromAssemblyInternal(currentAssembly);
compilationWithRoslynRef = Compilation.AddReferences(mdRef);
pluginBaseClass = compilationWithRoslynRef.GetTypeByMetadataName(ICompilerPluginAttributeName);
}
else
{
compilationWithRoslynRef = Compilation;
}
_pluginAttributes = GetPluginAttributes(compilationWithRoslynRef, pluginBaseClass);
if (_pluginAttributes == null)
{
return(false);
}
_plugins = new List <ICompilerPlugin>(_pluginAttributes.Count);
foreach (var pluginAttribute in _pluginAttributes)
{
try
{
_plugins.Add(InstantiatePlugin(compilationWithRoslynRef, pluginAttribute));
}
catch (Exception e)
{
INamedTypeSymbol attributeClass = pluginAttribute.AttributeClass;
string attributeName = attributeClass.ToDisplayString(SymbolDisplayFormat.QualifiedNameOnlyFormat);
AddExceptionDiagnostic(attributeName, e);
return(false);
}
}
return(true);
}
public void TestGeneratorsCantTargetNetFramework()
{
var directory = Temp.CreateDirectory();
// core
var errors = buildAndLoadGeneratorAndReturnAnyErrors(".NETCoreApp,Version=v5.0");
Assert.Empty(errors);
// netstandard
errors = buildAndLoadGeneratorAndReturnAnyErrors(".NETStandard,Version=v2.0");
Assert.Empty(errors);
// no target
errors = buildAndLoadGeneratorAndReturnAnyErrors(targetFramework: null);
Assert.Empty(errors);
// framework
errors = buildAndLoadGeneratorAndReturnAnyErrors(".NETFramework,Version=v4.7.2");
Assert.Equal(2, errors.Count);
Assert.Equal(AnalyzerLoadFailureEventArgs.FailureErrorCode.ReferencesFramework, errors.First().ErrorCode);
List <AnalyzerLoadFailureEventArgs> buildAndLoadGeneratorAndReturnAnyErrors(string?targetFramework)
{
string targetFrameworkAttributeText = targetFramework is object
?$"[assembly: System.Runtime.Versioning.TargetFramework(\"{targetFramework}\")]"
: string.Empty;
string generatorSource = $@"
using Microsoft.CodeAnalysis;
{targetFrameworkAttributeText}
[Generator]
public class Generator : ISourceGenerator
{{
public void Execute(GeneratorExecutionContext context) {{ }}
public void Initialize(GeneratorInitializationContext context) {{ }}
}}";
var directory = Temp.CreateDirectory();
var generatorPath = Path.Combine(directory.Path, $"generator_{targetFramework}.dll");
var compilation = CSharpCompilation.Create($"generator_{targetFramework}",
new[] { CSharpSyntaxTree.ParseText(generatorSource) },
TargetFrameworkUtil.GetReferences(TargetFramework.Standard, new[] { MetadataReference.CreateFromAssemblyInternal(typeof(ISourceGenerator).Assembly) }),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
compilation.VerifyDiagnostics();
var result = compilation.Emit(generatorPath);
Assert.True(result.Success);
AnalyzerFileReference reference = CreateAnalyzerFileReference(generatorPath);
List <AnalyzerLoadFailureEventArgs> errors = new List <AnalyzerLoadFailureEventArgs>();
void errorHandler(object?o, AnalyzerLoadFailureEventArgs e) => errors.Add(e);
reference.AnalyzerLoadFailed += errorHandler;
var builder = ImmutableArray.CreateBuilder <ISourceGenerator>();
reference.AddGenerators(builder, LanguageNames.CSharp);
reference.AnalyzerLoadFailed -= errorHandler;
if (errors.Count > 0)
{
Assert.Empty(builder);
}
else
{
Assert.Single(builder);
}
return(errors);
}
}
/// <summary>
/// Gets the references that need to be assigned to the compilation.
/// This can be different than the list of references defined by the <see cref="ScriptOptions"/> instance.
/// </summary>
internal ImmutableArray <MetadataReference> GetReferencesForCompilation(
CommonMessageProvider messageProvider,
DiagnosticBag diagnostics,
MetadataReference languageRuntimeReferenceOpt = null)
{
var resolver = Options.MetadataResolver;
var references = ArrayBuilder <MetadataReference> .GetInstance();
try
{
if (Previous == null)
{
var corLib = MetadataReference.CreateFromAssemblyInternal(typeof(object).GetTypeInfo().Assembly);
references.Add(corLib);
if (GlobalsType != null)
{
var globalsAssembly = GlobalsType.GetTypeInfo().Assembly;
// If the assembly doesn't have metadata (it's an in-memory or dynamic assembly),
// the host has to add reference to the metadata where globals type is located explicitly.
if (MetadataReference.HasMetadata(globalsAssembly))
{
references.Add(MetadataReference.CreateFromAssemblyInternal(globalsAssembly, HostAssemblyReferenceProperties));
}
}
if (languageRuntimeReferenceOpt != null)
{
references.Add(languageRuntimeReferenceOpt);
}
}
// add new references:
foreach (var reference in Options.MetadataReferences)
{
var unresolved = reference as UnresolvedMetadataReference;
if (unresolved != null)
{
var resolved = resolver.ResolveReference(unresolved.Reference, null, unresolved.Properties);
if (resolved.IsDefault)
{
diagnostics.Add(messageProvider.CreateDiagnostic(messageProvider.ERR_MetadataFileNotFound, Location.None, unresolved.Reference));
}
else
{
references.AddRange(resolved);
}
}
else
{
references.Add(reference);
}
}
return(references.ToImmutable());
}
finally
{
references.Free();
}
}
/// <summary>
/// Gets the references that need to be assigned to the compilation.
/// This can be different than the list of references defined by the <see cref="ScriptOptions"/> instance.
/// </summary>
internal ImmutableArray <MetadataReference> GetReferencesForCompilation(
CommonMessageProvider messageProvider,
DiagnosticBag diagnostics,
MetadataReference languageRuntimeReferenceOpt = null)
{
var resolver = Options.MetadataResolver;
var references = ArrayBuilder <MetadataReference> .GetInstance();
try
{
var previous = Previous;
if (previous != null)
{
// TODO: this should be done in reference manager
references.AddRange(previous.GetCompilation().References);
}
else
{
var corLib = MetadataReference.CreateFromAssemblyInternal(typeof(object).GetTypeInfo().Assembly);
references.Add(corLib);
if (GlobalsType != null)
{
var globalsTypeAssembly = MetadataReference.CreateFromAssemblyInternal(GlobalsType.GetTypeInfo().Assembly);
references.Add(globalsTypeAssembly);
}
if (languageRuntimeReferenceOpt != null)
{
references.Add(languageRuntimeReferenceOpt);
}
}
foreach (var reference in Options.MetadataReferences)
{
var unresolved = reference as UnresolvedMetadataReference;
if (unresolved != null)
{
var resolved = resolver.ResolveReference(unresolved.Reference, null, unresolved.Properties);
if (resolved.IsDefault)
{
diagnostics.Add(messageProvider.CreateDiagnostic(messageProvider.ERR_MetadataFileNotFound, Location.None, unresolved.Reference));
}
else
{
references.AddRange(resolved);
}
}
else
{
references.Add(reference);
}
}
return(references.ToImmutable());
}
finally
{
references.Free();
}
}
