public void RetargetMissingBaseType_Interface()
{
var source = @"
public interface Test : short { }
";
var comp = CreateEmptyCompilation(source);
comp.VerifyDiagnostics(
// (2,25): error CS0518: Predefined type 'System.Int16' is not defined or imported
// public interface Test : short { }
Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "short").WithArguments("System.Int16"),
// (2,18): error CS0518: Predefined type 'System.Int16' is not defined or imported
// public interface Test : short { }
Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "Test").WithArguments("System.Int16"));
var sourceAssembly = (SourceAssemblySymbol)comp.Assembly;
var sourceType = sourceAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("Test");
Assert.Equal(TypeKind.Error, sourceType.Interfaces().Single().TypeKind);
Assert.Equal(SpecialType.System_Int16, sourceType.Interfaces().Single().SpecialType);
Assert.Null(sourceType.BaseType());
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
var retargetingType = retargetingAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("Test");
Assert.Equal(TypeKind.Error, retargetingType.Interfaces().Single().TypeKind);
Assert.Equal(SpecialType.System_Int16, retargetingType.Interfaces().Single().SpecialType);
Assert.Null(retargetingType.BaseType());
}
public void RetargetInvalidConstraint()
{
var source = @"
public class C<T> where T : int
{
}
";
var comp = CreateCompilation(source);
comp.VerifyDiagnostics(
// (2,29): error CS0701: 'int' is not a valid constraint. A type used as a constraint must be an interface, a non-sealed class or a type parameter.
// public class C<T> where T : int
Diagnostic(ErrorCode.ERR_BadBoundType, "int").WithArguments("int"));
var sourceAssembly = (SourceAssemblySymbol)comp.Assembly;
var sourceType = sourceAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("C");
var sourceTypeParameter = sourceType.TypeParameters.Single();
Assert.Equal(0, sourceTypeParameter.ConstraintTypes().Length);
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
var retargetingType = retargetingAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("C");
var retargetingTypeParameter = retargetingType.TypeParameters.Single();
Assert.Equal(0, retargetingTypeParameter.ConstraintTypes().Length);
}
public void RetargetGenericConstraints()
{
var source =
@"interface I<T> { }
class C<T> where T : I<T>, new() { }
struct S<T> where T : struct
{
void M<U, V>()
where U : class, I<V>
{
}
}
delegate T D<T>() where T : I<T>;";
var compilation = CreateCompilation(source);
var sourceModule = compilation.SourceModule;
var sourceAssembly = (SourceAssemblySymbol)sourceModule.ContainingAssembly;
var sourceNamespace = sourceModule.GlobalNamespace;
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
retargetingAssembly.SetCorLibrary(sourceAssembly.CorLibrary);
var retargetingModule = retargetingAssembly.Modules[0];
var retargetingNamespace = retargetingModule.GlobalNamespace;
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("I"), retargetingNamespace.GetMember <NamedTypeSymbol>("I"));
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("C"), retargetingNamespace.GetMember <NamedTypeSymbol>("C"));
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("S"), retargetingNamespace.GetMember <NamedTypeSymbol>("S"));
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("D"), retargetingNamespace.GetMember <NamedTypeSymbol>("D"));
}
public void RetargetInvalidBaseType_Interface()
{
var source = @"
public interface Test : short { }
";
var comp = CreateCompilation(source);
comp.VerifyDiagnostics(
// (2,25): error CS0527: Type 'short' in interface list is not an interface
// public interface Test : short { }
Diagnostic(ErrorCode.ERR_NonInterfaceInInterfaceList, "short").WithArguments("short"));
var sourceAssembly = (SourceAssemblySymbol)comp.Assembly;
var sourceType = sourceAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("Test");
Assert.Equal(0, sourceType.Interfaces().Length);
Assert.Null(sourceType.BaseType());
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
var retargetingType = retargetingAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("Test");
Assert.Equal(0, retargetingType.Interfaces().Length);
Assert.Null(retargetingType.BaseType());
}
public void RetargetInvalidBaseType_Class()
{
var source = @"
public class Test : short { }
";
var comp = CreateCompilation(source);
comp.VerifyDiagnostics(
// (2,21): error CS0509: 'Test': cannot derive from sealed type 'short'
// public class Test : short { }
Diagnostic(ErrorCode.ERR_CantDeriveFromSealedType, "short").WithArguments("Test", "short"));
var sourceAssembly = (SourceAssemblySymbol)comp.Assembly;
var sourceType = sourceAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("Test");
Assert.Equal(0, sourceType.Interfaces().Length);
Assert.Equal(SpecialType.System_Object, sourceType.BaseType().SpecialType);
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
var retargetingType = retargetingAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("Test");
Assert.Equal(0, retargetingType.Interfaces().Length);
Assert.Equal(SpecialType.System_Object, retargetingType.BaseType().SpecialType);
}
public void RetargetFields()
{
var source = @"
using System.Runtime.InteropServices;
class D
{
}
class C
{
internal D F1;
[MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_DISPATCH, SafeArrayUserDefinedSubType = typeof(D))]
internal int F2;
}";
var compilation = CreateCompilation(source);
var sourceModule = compilation.SourceModule;
var sourceAssembly = (SourceAssemblySymbol)sourceModule.ContainingAssembly;
var sourceNamespace = sourceModule.GlobalNamespace;
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
retargetingAssembly.SetCorLibrary(sourceAssembly.CorLibrary);
var retargetingModule = retargetingAssembly.Modules[0];
var retargetingNamespace = retargetingModule.GlobalNamespace;
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("C"), retargetingNamespace.GetMember <NamedTypeSymbol>("C"));
Assert.IsType <RetargetingNamedTypeSymbol>(
retargetingNamespace.GetMember <NamedTypeSymbol>("C").GetMember <RetargetingFieldSymbol>("F2").MarshallingInformation.TryGetSafeArrayElementUserDefinedSubtype());
}
internal PEModuleSymbol(
RetargetingAssemblySymbol assemblySymbol,
PEModule module,
MetadataImportOptions importOptions,
int ordinal
) : this((AssemblySymbol)assemblySymbol, module, importOptions, ordinal)
{
Debug.Assert(ordinal > 0);
}
public void RetargetingUnmanagedTypeParameters(string code, bool isUnmanaged)
{
var compilation = CreateCompilation(code).VerifyDiagnostics();
var sourceAssembly = (SourceAssemblySymbol)compilation.Assembly;
SourceTypeParameterSymbol sourceTypeParameter = (SourceTypeParameterSymbol)sourceAssembly.GlobalNamespace.GetTypeMember("Test").TypeParameters.Single();
Assert.Equal(isUnmanaged, sourceTypeParameter.HasUnmanagedTypeConstraint);
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
retargetingAssembly.SetCorLibrary(sourceAssembly.CorLibrary);
RetargetingTypeParameterSymbol retargetingTypeParameter = (RetargetingTypeParameterSymbol)retargetingAssembly.GlobalNamespace.GetTypeMember("Test").TypeParameters.Single();
Assert.Equal(isUnmanaged, retargetingTypeParameter.HasUnmanagedTypeConstraint);
}
public void RetargetMissingConstraint()
{
var source = @"
public class C<T> where T : int
{
}
";
var comp = CreateEmptyCompilation(source);
comp.VerifyDiagnostics(
// (2,14): error CS0518: Predefined type 'System.Object' is not defined or imported
// public class C<T> where T : int
Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "C").WithArguments("System.Object"),
// (2,29): error CS0518: Predefined type 'System.Int32' is not defined or imported
// public class C<T> where T : int
Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "int").WithArguments("System.Int32"),
// (2,16): error CS0518: Predefined type 'System.Int32' is not defined or imported
// public class C<T> where T : int
Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "T").WithArguments("System.Int32"),
// (2,14): error CS1729: 'object' does not contain a constructor that takes 0 arguments
// public class C<T> where T : int
Diagnostic(ErrorCode.ERR_BadCtorArgCount, "C").WithArguments("object", "0"));
var sourceAssembly = (SourceAssemblySymbol)comp.Assembly;
var sourceType = sourceAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("C");
var sourceTypeParameter = sourceType.TypeParameters.Single();
var sourceTypeParameterConstraint = sourceTypeParameter.ConstraintTypes().Single();
Assert.Equal(TypeKind.Error, sourceTypeParameterConstraint.TypeKind);
Assert.Equal(SpecialType.System_Int32, sourceTypeParameterConstraint.SpecialType);
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
var retargetingType = retargetingAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("C");
var retargetingTypeParameter = retargetingType.TypeParameters.Single();
var retargetingTypeParameterConstraint = retargetingTypeParameter.ConstraintTypes().Single();
Assert.Equal(TypeKind.Error, retargetingTypeParameterConstraint.TypeKind);
Assert.Equal(SpecialType.System_Int32, retargetingTypeParameterConstraint.SpecialType);
}
public void RetargetMissingEnumUnderlyingType_Explicit()
{
var source = @"
public enum E : short
{
}
";
var comp = CreateEmptyCompilation(source);
comp.VerifyDiagnostics(
// (2,13): error CS0518: Predefined type 'System.Enum' is not defined or imported
// public enum E : short
Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "E").WithArguments("System.Enum"),
// (2,17): error CS0518: Predefined type 'System.Int16' is not defined or imported
// public enum E : short
Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "short").WithArguments("System.Int16"));
var sourceAssembly = (SourceAssemblySymbol)comp.Assembly;
var sourceType = sourceAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("E");
Assert.Equal(0, sourceType.Interfaces().Length); // Always returns an empty list for enums.
Assert.Equal(TypeKind.Error, sourceType.BaseType().TypeKind);
Assert.Equal(SpecialType.System_Enum, sourceType.BaseType().SpecialType);
Assert.Equal(TypeKind.Error, sourceType.EnumUnderlyingType.TypeKind);
Assert.Equal(SpecialType.System_Int16, sourceType.EnumUnderlyingType.SpecialType);
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
retargetingAssembly.SetCorLibrary(MissingCorLibrarySymbol.Instance); // Need to do this explicitly since our retargeting assembly wasn't constructed using the real mechanism.
var retargetingType = retargetingAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("E");
Assert.Equal(0, retargetingType.Interfaces().Length);
Assert.Equal(TypeKind.Error, retargetingType.BaseType().TypeKind);
Assert.Equal(SpecialType.System_Enum, retargetingType.BaseType().SpecialType);
Assert.Equal(TypeKind.Error, retargetingType.EnumUnderlyingType.TypeKind);
Assert.Equal(SpecialType.System_Int16, retargetingType.EnumUnderlyingType.SpecialType);
}
public void Retarget_IsSerializable()
{
var source = @"
public class Test { }
[System.Serializable]
public class TestS { }
";
var comp = CreateCompilation(source);
comp.VerifyDiagnostics();
var retargetingAssembly = new RetargetingAssemblySymbol((SourceAssemblySymbol)comp.Assembly, isLinked: false);
var retargetingType = retargetingAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("Test");
Assert.IsType <RetargetingNamedTypeSymbol>(retargetingType);
Assert.False(((INamedTypeSymbol)retargetingType).IsSerializable);
var retargetingTypeS = retargetingAssembly.GlobalNamespace.GetMember <NamedTypeSymbol>("TestS");
Assert.IsType <RetargetingNamedTypeSymbol>(retargetingTypeS);
Assert.True(((INamedTypeSymbol)retargetingTypeS).IsSerializable);
}
public void RetargetMethods()
{
var source = @"
using System.Runtime.InteropServices;
class C
{
[return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_DISPATCH, SafeArrayUserDefinedSubType = typeof(C))]
internal int M(
[MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_DISPATCH, SafeArrayUserDefinedSubType = typeof(C))]
int arg
)
{
return 1;
}
}";
var compilation = CreateCompilationWithMscorlib(source);
var sourceModule = compilation.SourceModule;
var sourceAssembly = (SourceAssemblySymbol)sourceModule.ContainingAssembly;
var sourceNamespace = sourceModule.GlobalNamespace;
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
retargetingAssembly.SetCorLibrary(sourceAssembly.CorLibrary);
var retargetingModule = retargetingAssembly.Modules[0];
var retargetingNamespace = retargetingModule.GlobalNamespace;
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("C"), retargetingNamespace.GetMember <NamedTypeSymbol>("C"));
Assert.IsType <RetargetingNamedTypeSymbol>(
retargetingNamespace.GetMember <NamedTypeSymbol>("C").GetMember <RetargetingMethodSymbol>("M").ReturnValueMarshallingInformation.TryGetSafeArrayElementUserDefinedSubtype());
Assert.IsType <RetargetingNamedTypeSymbol>(
((RetargetingParameterSymbol)retargetingNamespace.GetMember <NamedTypeSymbol>("C").GetMember <RetargetingMethodSymbol>("M").Parameters[0]).
MarshallingInformation.TryGetSafeArrayElementUserDefinedSubtype());
}
public void RetargetProperties()
{
var source =
@"interface I
{
object this[string x, object y] { get; set; }
}
struct S
{
I P { get { return null; } }
}
class C
{
internal I Q { get; private set; }
object this[I index]
{
get { return 0; }
set { }
}
}";
var compilation = CreateCompilation(source);
var sourceModule = compilation.SourceModule;
var sourceAssembly = (SourceAssemblySymbol)sourceModule.ContainingAssembly;
var sourceNamespace = sourceModule.GlobalNamespace;
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
retargetingAssembly.SetCorLibrary(sourceAssembly.CorLibrary);
var retargetingModule = retargetingAssembly.Modules[0];
var retargetingNamespace = retargetingModule.GlobalNamespace;
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("I"), retargetingNamespace.GetMember <NamedTypeSymbol>("I"));
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("S"), retargetingNamespace.GetMember <NamedTypeSymbol>("S"));
RetargetingSymbolChecker.CheckSymbols(sourceNamespace.GetMember <NamedTypeSymbol>("C"), retargetingNamespace.GetMember <NamedTypeSymbol>("C"));
}
public void RetargetExtensionMethods()
{
var source =
@"class C
{
}
static class S1
{
internal static void E(this object x, object y) { }
}
static class S2
{
internal static void E<T, U>(this T t, U u) { }
}";
var compilation = CreateCompilation(source);
var sourceModule = compilation.SourceModule;
var sourceAssembly = (SourceAssemblySymbol)sourceModule.ContainingAssembly;
var sourceNamespace = sourceModule.GlobalNamespace;
var retargetingAssembly = new RetargetingAssemblySymbol(sourceAssembly, isLinked: false);
retargetingAssembly.SetCorLibrary(sourceAssembly.CorLibrary);
var retargetingModule = retargetingAssembly.Modules[0];
var retargetingNamespace = retargetingModule.GlobalNamespace;
var sourceMethods = new ArrayBuilder <MethodSymbol>();
sourceNamespace.GetExtensionMethods(sourceMethods, null, 0, LookupOptions.AllMethodsOnArityZero);
Utils.CheckSymbols(sourceMethods.ToImmutable(),
"void S1.E(object x, object y)",
"void S2.E<T, U>(T t, U u)");
var retargetingMethods = new ArrayBuilder <MethodSymbol>();
retargetingNamespace.GetExtensionMethods(retargetingMethods, null, 0, LookupOptions.AllMethodsOnArityZero);
Utils.CheckSymbols(retargetingMethods.ToImmutable(),
"void S1.E(object x, object y)",
"void S2.E<T, U>(T t, U u)");
for (int i = 0; i < sourceMethods.Count; i++)
{
CheckMethods(sourceMethods[i], retargetingMethods[i]);
}
sourceMethods = new ArrayBuilder <MethodSymbol>();
sourceNamespace.GetExtensionMethods(sourceMethods, "E", 2, LookupOptions.Default);
Utils.CheckSymbols(sourceMethods.ToImmutable(),
"void S2.E<T, U>(T t, U u)");
var sourceMethod = sourceMethods[0];
retargetingMethods = new ArrayBuilder <MethodSymbol>();
retargetingNamespace.GetExtensionMethods(retargetingMethods, "E", 2, LookupOptions.Default);
Utils.CheckSymbols(retargetingMethods.ToImmutable(),
"void S2.E<T, U>(T t, U u)");
var retargetingMethod = retargetingMethods[0];
var sourceType = sourceNamespace.GetMember <NamedTypeSymbol>("C");
var retargetingType = retargetingNamespace.GetMember <NamedTypeSymbol>("C");
CheckTypes(sourceType, retargetingType);
CheckMethods(sourceMethod, retargetingMethod);
var sourceReduced = sourceMethod.ReduceExtensionMethod(sourceType);
var retargetingReduced = retargetingMethod.ReduceExtensionMethod(retargetingType);
CheckReducedExtensionMethods(sourceReduced, retargetingReduced);
}
