internal static BoundStatement ParseAndBindMethodBody(string program, bool lower, string typeName = DefaultTypeName, string methodName = DefaultMethodName)
{
var compilation = CreateCompilationWithMscorlib(program);
var method = (MethodSymbol)compilation.GlobalNamespace.GetTypeMembers(typeName).Single().GetMembers(methodName).Single();
var diagnostics = DiagnosticBag.GetInstance();
try
{
// Provide an Emit.Module so that the lowering passes will be run
var module = new PEAssemblyBuilder(
(SourceAssemblySymbol)compilation.Assembly,
EmitOptions.Default,
OutputKind.ConsoleApplication,
GetDefaultModulePropertiesForSerialization(),
Enumerable.Empty<ResourceDescription>(),
assemblySymbolMapper: null);
TypeCompilationState compilationState = new TypeCompilationState(method.ContainingType, compilation, module);
var block = MethodCompiler.BindMethodBody(method, compilationState, diagnostics);
if ((block == null) || !lower)
{
return block;
}
StateMachineTypeSymbol stateMachineTypeOpt;
VariableSlotAllocator lazyVariableSlotAllocator = null;
var lambdaDebugInfoBuilder = ArrayBuilder<LambdaDebugInfo>.GetInstance();
var closureDebugInfoBuilder = ArrayBuilder<ClosureDebugInfo>.GetInstance();
var body = MethodCompiler.LowerBodyOrInitializer(
method: method,
methodOrdinal: 0,
body: block,
previousSubmissionFields: null,
compilationState: compilationState,
diagnostics: diagnostics,
lazyVariableSlotAllocator: ref lazyVariableSlotAllocator,
lambdaDebugInfoBuilder: lambdaDebugInfoBuilder,
closureDebugInfoBuilder: closureDebugInfoBuilder,
stateMachineTypeOpt: out stateMachineTypeOpt);
lambdaDebugInfoBuilder.Free();
closureDebugInfoBuilder.Free();
return body;
}
finally
{
diagnostics.Free();
}
}
internal static BoundBlock ParseAndBindMethodBody(string program, string typeName = DefaultTypeName, string methodName = DefaultMethodName)
{
var compilation = CreateCompilationWithMscorlib(program);
var method = (MethodSymbol)compilation.GlobalNamespace.GetTypeMembers(typeName).Single().GetMembers(methodName).Single();
// Provide an Emit.Module so that the lowering passes will be run
var module = new PEAssemblyBuilder(
(SourceAssemblySymbol)compilation.Assembly,
emitOptions: EmitOptions.Default,
outputKind: OutputKind.ConsoleApplication,
serializationProperties: GetDefaultModulePropertiesForSerialization(),
manifestResources: Enumerable.Empty<ResourceDescription>());
TypeCompilationState compilationState = new TypeCompilationState(method.ContainingType, compilation, module);
var diagnostics = DiagnosticBag.GetInstance();
var block = MethodCompiler.BindMethodBody(method, compilationState, diagnostics);
diagnostics.Free();
return block;
}
internal static BoundStatement ParseAndBindMethodBody(string program, bool lower, string typeName = DefaultTypeName, string methodName = DefaultMethodName)
{
var compilation = CreateCompilationWithMscorlib(program);
var method = (MethodSymbol)compilation.GlobalNamespace.GetTypeMembers(typeName).Single().GetMembers(methodName).Single();
var diagnostics = DiagnosticBag.GetInstance();
try
{
var block = Compiler.BindMethodBody(method, diagnostics);
if ((block == null) || !lower)
{
return block;
}
// Provide an Emit.Module so that the lowering passes will be run
var module = new PEAssemblyBuilder(
(SourceAssemblySymbol)compilation.Assembly,
null,
OutputKind.ConsoleApplication,
GetDefaultModulePropertiesForSerialization(),
Enumerable.Empty<ResourceDescription>(),
assemblySymbolMapper: null);
TypeCompilationState compilationState = new TypeCompilationState(method.ContainingType, module);
var body = Compiler.LowerStatement(
generateDebugInfo: true,
method: method,
body: block,
previousSubmissionFields: null,
compilationState: compilationState,
diagnostics: diagnostics);
return body;
}
finally
{
diagnostics.Free();
}
}
internal static void VerifyParamArrayAttribute(ParameterSymbol parameter, SourceModuleSymbol module, bool expected = true, OutputKind outputKind = OutputKind.ConsoleApplication)
{
Assert.Equal(expected, parameter.IsParams);
var emitModule = new PEAssemblyBuilder(module.ContainingSourceAssembly, null, outputKind, GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var paramArrayAttributeCtor = (MethodSymbol)emitModule.Compilation.GetWellKnownTypeMember(WellKnownMember.System_ParamArrayAttribute__ctor);
bool found = false;
var context = new EmitContext(emitModule, null, new DiagnosticBag());
foreach (Microsoft.Cci.ICustomAttribute attr in parameter.GetSynthesizedAttributes())
{
if (paramArrayAttributeCtor == (MethodSymbol)attr.Constructor(context))
{
Assert.False(found, "Multiple ParamArrayAttribute");
found = true;
}
}
Assert.Equal(expected, found);
context.Diagnostics.Verify();
}
public void EmitMetadataOnly_SynthesizedExplicitImplementations()
{
var ilAssemblyReference = TestReferences.SymbolsTests.CustomModifiers.CppCli.dll;
var libAssemblyName = "SynthesizedMethodMetadata";
var exeAssemblyName = "CallSynthesizedMethod";
// Setup: CppBase2 has methods that implement CppInterface1, but it doesn't declare
// that it implements the interface. Class1 does declare that it implements the
// interface, but it's empty so it counts on CppBase2 to provide the implementations.
// Since CppBase2 is not in the current source module, bridge methods are inserted
// into Class1 to implement the interface methods by delegating to CppBase2.
var libText = @"
public class Class1 : CppCli.CppBase2, CppCli.CppInterface1
{
}
";
var libComp = CreateCompilationWithMscorlib(
text: libText,
references: new MetadataReference[] { ilAssemblyReference },
compOptions: TestOptions.Dll,
assemblyName: libAssemblyName);
Assert.False(libComp.GetDiagnostics().Any());
EmitResult emitResult;
byte[] dllImage;
using (var output = new MemoryStream())
{
emitResult = libComp.EmitMetadataOnly(output);
dllImage = output.ToArray();
}
Assert.True(emitResult.Success);
emitResult.Diagnostics.Verify();
Assert.True(dllImage.Length > 0, "no metadata emitted");
// NOTE: this DLL won't PEVerify because there are no method bodies.
var class1 = libComp.GlobalNamespace.GetMember<SourceNamedTypeSymbol>("Class1");
// We would prefer to check that the module used by Compiler.Emit does the right thing,
// but we don't have access to that object, so we'll create our own and manipulate it
// in the same way.
var module = new PEAssemblyBuilder((SourceAssemblySymbol)class1.ContainingAssembly, null,
OutputKind.DynamicallyLinkedLibrary, GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
Compiler.CompileSynthesizedMethodMetadata(libComp, module, default(CancellationToken));
var class1TypeDef = (Cci.ITypeDefinition)class1;
var symbolSynthesized = class1.GetSynthesizedExplicitImplementations(CancellationToken.None);
var context = new Microsoft.CodeAnalysis.Emit.Context(module, null, new DiagnosticBag());
var cciExplicit = class1TypeDef.GetExplicitImplementationOverrides(context);
var cciMethods = class1TypeDef.GetMethods(context).Where(m => ((MethodSymbol)m).MethodKind != MethodKind.Constructor);
context.Diagnostics.Verify();
var symbolsSynthesizedCount = symbolSynthesized.Length;
Assert.True(symbolsSynthesizedCount > 0, "Expected more than 0 synthesized method symbols.");
Assert.Equal(symbolsSynthesizedCount, cciExplicit.Count());
Assert.Equal(symbolsSynthesizedCount, cciMethods.Count());
var libAssemblyReference = new MetadataImageReference(dllImage.AsImmutableOrNull());
var exeText = @"
class Class2
{
public static void Main()
{
CppCli.CppInterface1 c = new Class1();
c.Method1(1);
c.Method2(2);
}
}
";
var exeComp = CreateCompilationWithMscorlib(
text: exeText,
references: new MetadataReference[] { ilAssemblyReference, libAssemblyReference },
assemblyName: exeAssemblyName);
Assert.False(exeComp.GetDiagnostics().Any());
using (var output = new MemoryStream())
{
emitResult = exeComp.Emit(output);
Assert.True(emitResult.Success);
emitResult.Diagnostics.Verify();
output.Flush();
Assert.True(output.Length > 0, "no metadata emitted");
}
// NOTE: there's no point in trying to run the EXE since it depends on a DLL with no method bodies.
}
public void IgnoreOtherDiagnosticsCompilingSynthesizedMethods()
{
var source =
@"class C
{
static object F = new object(); // generate .cctor
static System.Action M()
{
return () => { }; // generate lambda
}
}";
var compilation = CreateCompilationWithMscorlib(source, options: TestOptions.ReleaseDll.WithConcurrentBuild(false));
var options = compilation.Options;
var diagnostics = DiagnosticBag.GetInstance();
var assembly = (SourceAssemblySymbol)compilation.Assembly;
var module = new PEAssemblyBuilder(
assembly,
EmitOptions.Default,
options.OutputKind,
GetDefaultModulePropertiesForSerialization(),
new ResourceDescription[0]);
var methodBodyCompiler = new MethodCompiler(
compilation: compilation,
moduleBeingBuiltOpt: module,
emittingPdb: false,
hasDeclarationErrors: false,
diagnostics: diagnostics,
filterOpt: null,
cancellationToken: CancellationToken.None);
// Add diagnostic to MethodBodyCompiler bag, as if
// code gen for an earlier method had generated an error.
diagnostics.Add(new CSDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_IntDivByZero), NoLocation.Singleton));
// Compile all methods for type including synthesized methods.
var type = compilation.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
methodBodyCompiler.Visit(type);
Assert.Equal(1, diagnostics.AsEnumerable().Count());
diagnostics.Free();
}
public void MethodAccessorMethodOverriding()
{
var text = @"
public class A
{
public virtual int get_P() { return 0; }
}
public class B : A
{
public virtual int P { get; set; }
}
public class C : B
{
public override int get_P() { return 0; }
}
";
var comp = CreateCompilationWithMscorlib(text);
comp.VerifyDiagnostics();
var globalNamespace = comp.GlobalNamespace;
var classA = globalNamespace.GetMember<NamedTypeSymbol>("A");
var classB = globalNamespace.GetMember<NamedTypeSymbol>("B");
var classC = globalNamespace.GetMember<NamedTypeSymbol>("C");
var methodA = classA.GetMember<MethodSymbol>("get_P");
var methodB = classB.GetMember<PropertySymbol>("P").GetMethod;
var methodC = classC.GetMember<MethodSymbol>("get_P");
var typeDefC = (Cci.ITypeDefinition)classC;
var module = new PEAssemblyBuilder((SourceAssemblySymbol)classC.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var context = new EmitContext(module, null, new DiagnosticBag());
var explicitOverride = typeDefC.GetExplicitImplementationOverrides(context).Single();
Assert.Equal(classC, explicitOverride.ContainingType);
Assert.Equal(methodC, explicitOverride.ImplementingMethod);
Assert.Equal(methodA, explicitOverride.ImplementedMethod);
context.Diagnostics.Verify();
}
public void ExplicitInterfaceImplementationGeneric()
{
string text = @"
namespace Namespace
{
interface I<T>
{
void Method(T t);
}
}
class IC : Namespace.I<int>
{
void Namespace.I<int>.Method(int i) { }
}
";
var comp = CreateCompilationWithMscorlib(Parse(text));
var globalNamespace = comp.GlobalNamespace;
var systemNamespace = (NamespaceSymbol)globalNamespace.GetMembers("Namespace").Single();
var @interface = (NamedTypeSymbol)systemNamespace.GetTypeMembers("I", 1).Single();
Assert.Equal(TypeKind.Interface, @interface.TypeKind);
var interfaceMethod = (MethodSymbol)@interface.GetMembers("Method").Single();
var @class = (NamedTypeSymbol)globalNamespace.GetTypeMembers("IC").Single();
Assert.Equal(TypeKind.Class, @class.TypeKind);
var substitutedInterface = @class.Interfaces.Single();
Assert.Equal(@interface, substitutedInterface.ConstructedFrom);
var substitutedInterfaceMethod = (MethodSymbol)substitutedInterface.GetMembers("Method").Single();
var classMethod = (MethodSymbol)@class.GetMembers("Namespace.I<System.Int32>.Method").Single();
Assert.Equal(MethodKind.ExplicitInterfaceImplementation, classMethod.MethodKind);
var explicitImpl = classMethod.ExplicitInterfaceImplementations.Single();
Assert.Equal(substitutedInterface, explicitImpl.ContainingType);
Assert.Equal(substitutedInterfaceMethod.OriginalDefinition, explicitImpl.OriginalDefinition);
var typeDef = (Cci.ITypeDefinition)@class;
var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var context = new EmitContext(module, null, new DiagnosticBag());
var explicitOverride = typeDef.GetExplicitImplementationOverrides(context).Single();
Assert.Equal(@class, explicitOverride.ContainingType);
Assert.Equal(classMethod, explicitOverride.ImplementingMethod);
var explicitOverrideImplementedMethod = explicitOverride.ImplementedMethod;
Assert.Equal(substitutedInterface, explicitOverrideImplementedMethod.GetContainingType(context));
Assert.Equal(substitutedInterfaceMethod.Name, explicitOverrideImplementedMethod.Name);
Assert.Equal(substitutedInterfaceMethod.Arity, explicitOverrideImplementedMethod.GenericParameterCount);
context.Diagnostics.Verify();
}
public void ExplicitInterfaceImplementationRef()
{
string text = @"
interface I
{
ref int Method(ref int i);
}
class C : I
{
ref int I.Method(ref int i) { return ref i; }
}
";
var comp = CreateCompilationWithMscorlib45(text);
var globalNamespace = comp.GlobalNamespace;
var @interface = (NamedTypeSymbol)globalNamespace.GetTypeMembers("I").Single();
Assert.Equal(TypeKind.Interface, @interface.TypeKind);
var interfaceMethod = (MethodSymbol)@interface.GetMembers("Method").Single();
Assert.Equal(RefKind.Ref, interfaceMethod.RefKind);
var @class = (NamedTypeSymbol)globalNamespace.GetTypeMembers("C").Single();
Assert.Equal(TypeKind.Class, @class.TypeKind);
Assert.True(@class.Interfaces.Contains(@interface));
var classMethod = (MethodSymbol)@class.GetMembers("I.Method").Single();
Assert.Equal(MethodKind.ExplicitInterfaceImplementation, classMethod.MethodKind);
Assert.Equal(RefKind.Ref, classMethod.RefKind);
var explicitImpl = classMethod.ExplicitInterfaceImplementations.Single();
Assert.Equal(interfaceMethod, explicitImpl);
var typeDef = (Cci.ITypeDefinition)@class;
var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var context = new EmitContext(module, null, new DiagnosticBag());
var explicitOverride = typeDef.GetExplicitImplementationOverrides(context).Single();
Assert.Equal(@class, explicitOverride.ContainingType);
Assert.Equal(classMethod, explicitOverride.ImplementingMethod);
Assert.Equal(interfaceMethod, explicitOverride.ImplementedMethod);
context.Diagnostics.Verify();
}
public void ExplicitInterfaceImplementationCorLib()
{
string text = @"
class F : System.IFormattable
{
string System.IFormattable.ToString(string format, System.IFormatProvider formatProvider)
{
return null;
}
}
";
var comp = CreateCompilationWithMscorlib(Parse(text));
var globalNamespace = comp.GlobalNamespace;
var systemNamespace = (NamespaceSymbol)globalNamespace.GetMembers("System").Single();
var @interface = (NamedTypeSymbol)systemNamespace.GetTypeMembers("IFormattable").Single();
Assert.Equal(TypeKind.Interface, @interface.TypeKind);
var interfaceMethod = (MethodSymbol)@interface.GetMembers("ToString").Single();
var @class = (NamedTypeSymbol)globalNamespace.GetTypeMembers("F").Single();
Assert.Equal(TypeKind.Class, @class.TypeKind);
Assert.True(@class.Interfaces.Contains(@interface));
var classMethod = (MethodSymbol)@class.GetMembers("System.IFormattable.ToString").Single();
Assert.Equal(MethodKind.ExplicitInterfaceImplementation, classMethod.MethodKind);
var explicitImpl = classMethod.ExplicitInterfaceImplementations.Single();
Assert.Equal(interfaceMethod, explicitImpl);
var typeDef = (Cci.ITypeDefinition)@class;
var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var context = new EmitContext(module, null, new DiagnosticBag());
var explicitOverride = typeDef.GetExplicitImplementationOverrides(context).Single();
Assert.Equal(@class, explicitOverride.ContainingType);
Assert.Equal(classMethod, explicitOverride.ImplementingMethod);
Assert.Equal(interfaceMethod, explicitOverride.ImplementedMethod);
context.Diagnostics.Verify();
}
public void ExtensionMethod_ValidateExtensionAttribute()
{
var source =
@"using System;
internal static class C
{
internal static void M1(this object o) { }
private static void Main(string[] args) { }
}
";
Action<ModuleSymbol> validator = module =>
{
var type = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
// Extension method.
var method = type.GetMember<MethodSymbol>("M1");
Assert.True(method.IsExtensionMethod);
var parameter = method.Parameters[0];
Assert.Equal(parameter.Type.SpecialType, SpecialType.System_Object);
// Validate Extension attribute.
var sourceModule = (SourceModuleSymbol)module;
var emitModule = new PEAssemblyBuilder(sourceModule.ContainingSourceAssembly, EmitOptions.Default, OutputKind.ConsoleApplication, GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var attrs = method.GetSynthesizedAttributes();
Assert.Equal(1, attrs.Length);
var attr = (Microsoft.Cci.ICustomAttribute)attrs.First();
var extensionAttrCtor = (MethodSymbol)emitModule.Compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_ExtensionAttribute__ctor);
Assert.NotNull(extensionAttrCtor);
var context = new EmitContext(emitModule, null, new DiagnosticBag());
Assert.Equal(extensionAttrCtor, attr.Constructor(context));
Assert.NotNull(extensionAttrCtor.ContainingType);
Assert.Equal(extensionAttrCtor.ContainingType, attr.GetType(context));
context.Diagnostics.Verify();
};
CompileAndVerify(source, additionalRefs: new[] { SystemCoreRef }, sourceSymbolValidator: validator, symbolValidator: null);
}
private static void CheckPropertyExplicitImplementation(NamedTypeSymbol @class, PropertySymbol classProperty, PropertySymbol interfaceProperty)
{
var interfacePropertyGetter = interfaceProperty.GetMethod;
Assert.NotNull(interfacePropertyGetter);
var interfacePropertySetter = interfaceProperty.SetMethod;
Assert.NotNull(interfacePropertySetter);
Assert.Equal(interfaceProperty, classProperty.ExplicitInterfaceImplementations.Single());
var classPropertyGetter = classProperty.GetMethod;
Assert.NotNull(classPropertyGetter);
var classPropertySetter = classProperty.SetMethod;
Assert.NotNull(classPropertySetter);
Assert.Equal(interfacePropertyGetter, classPropertyGetter.ExplicitInterfaceImplementations.Single());
Assert.Equal(interfacePropertySetter, classPropertySetter.ExplicitInterfaceImplementations.Single());
var typeDef = (Microsoft.Cci.ITypeDefinition)@class;
var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var context = new EmitContext(module, null, new DiagnosticBag());
var explicitOverrides = typeDef.GetExplicitImplementationOverrides(context);
Assert.Equal(2, explicitOverrides.Count());
Assert.True(explicitOverrides.All(@override => ReferenceEquals(@class, @override.ContainingType)));
// We're not actually asserting that the overrides are in this order - set comparison just seems like overkill for two elements
var getterOverride = explicitOverrides.First();
Assert.Equal(classPropertyGetter, getterOverride.ImplementingMethod);
Assert.Equal(interfacePropertyGetter.ContainingType, getterOverride.ImplementedMethod.GetContainingType(context));
Assert.Equal(interfacePropertyGetter.Name, getterOverride.ImplementedMethod.Name);
var setterOverride = explicitOverrides.Last();
Assert.Equal(classPropertySetter, setterOverride.ImplementingMethod);
Assert.Equal(interfacePropertySetter.ContainingType, setterOverride.ImplementedMethod.GetContainingType(context));
Assert.Equal(interfacePropertySetter.Name, setterOverride.ImplementedMethod.Name);
context.Diagnostics.Verify();
}
private void CheckEnumType(NamedTypeSymbol type, Accessibility declaredAccessibility, SpecialType underlyingType)
{
Assert.Equal(type.BaseType.SpecialType, SpecialType.System_Enum);
Assert.Equal(type.EnumUnderlyingType.SpecialType, underlyingType);
Assert.Equal(type.DeclaredAccessibility, declaredAccessibility);
Assert.True(type.IsSealed);
// value__ field should not be exposed from type, even though it is public,
// since we want to prevent source from accessing the field directly.
var field = type.GetMembers(WellKnownMemberNames.EnumBackingFieldName).SingleOrDefault() as FieldSymbol;
Assert.Null(field);
var sourceType = type as SourceNamedTypeSymbol;
if (sourceType != null)
{
field = sourceType.EnumValueField;
Assert.NotNull(field);
Assert.Equal(field.Name, WellKnownMemberNames.EnumBackingFieldName);
Assert.False(field.IsStatic);
Assert.False(field.IsConst);
Assert.False(field.IsReadOnly);
Assert.Equal(field.DeclaredAccessibility, Accessibility.Public); // Dev10: value__ is public
Assert.Equal(field.Type, type.EnumUnderlyingType);
var module = new PEAssemblyBuilder((SourceAssemblySymbol)sourceType.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var context = new EmitContext(module, null, new DiagnosticBag());
var typeDefinition = (Microsoft.Cci.ITypeDefinition)type;
var fieldDefinition = typeDefinition.GetFields(context).First();
Assert.Same(fieldDefinition, field); // Dev10: value__ field is the first field.
Assert.True(fieldDefinition.IsSpecialName);
Assert.True(fieldDefinition.IsRuntimeSpecial);
context.Diagnostics.Verify();
}
}
public void AssemblyRefs_DuplicateRows()
{
var compilation = CreateCompilationWithMscorlib(
"class C : C1 { }; class D { }",
new[] { TestReferences.SymbolsTests.Methods.CSMethods });
PEAssemblyBuilder assembly = new PEAssemblyBuilder(
(SourceAssemblySymbol)compilation.Assembly,
EmitOptions.Default,
compilation.Options.OutputKind,
GetDefaultModulePropertiesForSerialization(),
Enumerable.Empty<ResourceDescription>(),
// map all references to a single name:
assembylSymbol => new AssemblyIdentity("foo")
);
// Don't attempt to emit if there were any syntax, declaration, semantic, or emitted errors previously.
DiagnosticBag diagnostics = new DiagnosticBag();
MethodCompiler.CompileMethodBodies(
compilation: compilation,
moduleBeingBuiltOpt: assembly,
generateDebugInfo: false,
hasDeclarationErrors: false,
diagnostics: diagnostics,
filterOpt: null,
cancellationToken: default(CancellationToken));
diagnostics.Verify();
var context = new EmitContext(assembly, null, new DiagnosticBag());
ImmutableArray<byte> image;
using (var stream = new MemoryStream())
{
Cci.PeWriter.WritePeToStream(
context,
compilation.MessageProvider,
stream,
nativePdbWriterOpt: null,
allowMissingMethodBodies: false,
deterministic: false,
cancellationToken: CancellationToken.None);
image = stream.ToImmutable();
}
context.Diagnostics.Verify();
// check that there are no duplicate rows in AssemblyRef table:
PEAssembly emittedAssembly = AssemblyMetadata.CreateFromImage(image).GetAssembly();
var emittedReferences = emittedAssembly.Modules[0].ReferencedAssemblies;
Assert.Equal(1, emittedReferences.Length);
Assert.Equal("foo", emittedReferences[0].Name);
}
public void BaseInterfacesInMetadata()
{
var text = @"
interface I1 { }
interface I2 : I1 { }
class C : I2 { }
";
var comp = CreateCompilationWithMscorlib(text);
var global = comp.GlobalNamespace;
var baseInterface = global.GetMember<NamedTypeSymbol>("I1");
var derivedInterface = global.GetMember<NamedTypeSymbol>("I2");
var @class = global.GetMember<NamedTypeSymbol>("C");
var bothInterfaces = ImmutableArray.Create<NamedTypeSymbol>(baseInterface, derivedInterface);
Assert.Equal(baseInterface, derivedInterface.AllInterfaces.Single());
Assert.Equal(derivedInterface, @class.Interfaces.Single());
Assert.True(@class.AllInterfaces.SetEquals(bothInterfaces, EqualityComparer<NamedTypeSymbol>.Default));
var typeDef = (Cci.ITypeDefinition)@class;
var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary,
GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>());
var context = new EmitContext(module, null, new DiagnosticBag());
var cciInterfaces = typeDef.Interfaces(context).Cast<NamedTypeSymbol>().AsImmutable();
Assert.True(cciInterfaces.SetEquals(bothInterfaces, EqualityComparer<NamedTypeSymbol>.Default));
context.Diagnostics.Verify();
}
internal CommonPEModuleBuilder CreateModuleBuilder(
string outputName,
IEnumerable<ResourceDescription> manifestResources,
Func<IAssemblySymbol, AssemblyIdentity> assemblySymbolMapper,
CancellationToken cancellationToken,
CompilationTestData testData,
DiagnosticBag diagnostics,
bool metadataOnly,
ImmutableArray<NamedTypeSymbol> additionalTypes)
{
// Do not waste a slot in the submission chain for submissions that contain no executable code
// (they may only contain #r directives, usings, etc.)
if (IsSubmission && !HasCodeToEmit())
{
return null;
}
string runtimeMDVersion = GetRuntimeMetadataVersion(diagnostics);
if (runtimeMDVersion == null)
{
return null;
}
var moduleProps = ConstructModuleSerializationProperties(runtimeMDVersion);
if (manifestResources == null)
{
manifestResources = SpecializedCollections.EmptyEnumerable<ResourceDescription>();
}
PEModuleBuilder moduleBeingBuilt;
if (options.OutputKind.IsNetModule())
{
Debug.Assert(additionalTypes.IsEmpty);
moduleBeingBuilt = new PENetModuleBuilder(
(SourceModuleSymbol)SourceModule,
outputName,
moduleProps,
manifestResources,
metadataOnly);
}
else
{
var kind = options.OutputKind.IsValid() ? options.OutputKind : OutputKind.DynamicallyLinkedLibrary;
moduleBeingBuilt = new PEAssemblyBuilder(
SourceAssembly,
outputName,
kind,
moduleProps,
manifestResources,
assemblySymbolMapper,
additionalTypes,
metadataOnly);
}
// testData is only passed when running tests.
if (testData != null)
{
moduleBeingBuilt.SetMethodTestData(testData.Methods);
testData.Module = moduleBeingBuilt;
}
return moduleBeingBuilt;
}
internal CommonPEModuleBuilder CreateModuleBuilder(
string outputName,
IEnumerable<ResourceDescription> manifestResources,
Func<IAssemblySymbol, AssemblyIdentity> assemblySymbolMapper,
ImmutableArray<NamedTypeSymbol> additionalTypes,
CancellationToken cancellationToken,
CompilationTestData testData,
DiagnosticBag diagnostics,
ref bool hasDeclarationErrors,
bool metadataOnly)
{
// The diagnostics should include syntax and declaration errors also. We insert these before calling Emitter.Emit, so that the emitter
// does not attempt to emit if there are declaration errors (but we do insert all errors from method body binding...)
if (!FilterAndAppendDiagnostics(
diagnostics,
GetDiagnostics(CompilationStage.Declare, true, cancellationToken),
this.options))
{
hasDeclarationErrors = true;
}
// Do not waste a slot in the submission chain for submissions that contain no executable code
// (they may only contain #r directives, usings, etc.)
if (IsSubmission && !HasCodeToEmit())
{
return null;
}
string runtimeMDVersion = GetRuntimeMetadataVersion(diagnostics);
if (runtimeMDVersion == null)
{
return null;
}
var moduleProps = ConstructModuleSerializationProperties(runtimeMDVersion);
if (manifestResources == null)
{
manifestResources = SpecializedCollections.EmptyEnumerable<ResourceDescription>();
}
PEModuleBuilder moduleBeingBuilt;
if (options.OutputKind.IsNetModule())
{
Debug.Assert(additionalTypes.IsEmpty);
moduleBeingBuilt = new PENetModuleBuilder(
(SourceModuleSymbol)SourceModule,
outputName,
moduleProps,
manifestResources,
metadataOnly);
}
else
{
var kind = options.OutputKind.IsValid() ? options.OutputKind : OutputKind.DynamicallyLinkedLibrary;
moduleBeingBuilt = new PEAssemblyBuilder(
SourceAssembly,
outputName,
kind,
moduleProps,
manifestResources,
assemblySymbolMapper,
additionalTypes,
metadataOnly);
}
// testData is only passed when running tests.
if (testData != null)
{
moduleBeingBuilt.SetMethodTestData(testData.Methods);
testData.Module = moduleBeingBuilt;
}
return moduleBeingBuilt;
}
