# mention all targets
all-local $(STD_TARGETS:=-local):
-VALID_PROFILE := $(filter net_2_0 net_2_1 net_4_0, $(PROFILE))
+VALID_PROFILE := $(filter net_2_0 moonlight net_4_0, $(PROFILE))
ifdef VALID_PROFILE
--check: run-mcs-tests
++qcheck: run-mcs-tests
# again, run-test is when the tests actually happen, so
# don't compile on make test.
run-mcs-tests: $(TEST_SUPPORT_FILES)
$(TESTER) -mode:neg -files:$(TEST_PATTERN) -compiler:$(COMPILER) -issues:known-issues-$(COMPILER_NAME) -log:$(COMPILER_NAME).log $(TESTER_OPTIONS)
--cecil:
-- $(TESTER) -mode:neg -files:$(TEST_PATTERN) -compiler:../tests/gmcs.exe -issues:known-issues-$(COMPILER_NAME) -log:$(COMPILER_NAME).log $(TESTER_OPTIONS) -verbose
--
endif
clean-local:
--- /dev/null
--- /dev/null
++// CS0111:
++// Line: 8
++
++using System;
++
++class Test {}
++
++namespace Test
++{
++ public class Foo
++ {
++ public static void Main ()
++ {
++ Test t = new Test ();
++ }
++ }
++}
+++ /dev/null
--// cs0117-2.cs: `A' does not contain a definition for `Foo'
--// Line: 15
--using System;
--using System.Runtime.CompilerServices;
--
--class A
--{
-- [IndexerName ("Foo")]
-- public int this [int index] {
-- get { return index; }
-- }
--
-- static int Test (A a)
-- {
-- return a.Foo;
-- }
--
-- public static void Main ()
-- {
-- Test (new A ());
-- }
--}
+++ /dev/null
--// cs0117-3.cs: `A' does not contain a definition for `Foo'
--// Line: 16
--using System;
--using System.Runtime.CompilerServices;
--
--class A
--{
-- [IndexerName ("Foo")]
-- public int this [int index] {
-- get { return index; }
-- set { ; }
-- }
--
-- static void Test (A a, int value)
-- {
-- a.Foo = value;
-- }
--
-- public static void Main ()
-- {
-- Test (new A (), 9);
-- }
--}
--- /dev/null
--- /dev/null
++// CS0121: The call is ambiguous between the following methods or properties: `IList.Count()' and `ICounter.Count()'
++// Line: 33\r
++
++using System;
++
++interface IList \r
++{
++ int Count ();
++}
++
++interface ICounter \r
++{
++ int Count ();
++}\r
++\r
++interface ICollection\r
++{\r
++ int Count { set; }\r
++}
++
++interface IListCounter: IList, ICounter, ICollection\r
++{\r
++}\r
++\r
++interface IListCounterNew : IListCounter\r
++{\r
++}
++
++class Test\r
++{
++ static void Foo (IListCounterNew t)
++ {
++ t.Count ();
++ }
++}
--// CS0121: The call is ambiguous between the following methods or properties: `B.operator +(A, B)' and `A.operator +(A, B)'
++// CS0121: The call is ambiguous between the following methods or properties: `A.operator +(A, B)' and `B.operator +(A, B)'
// Line: 21
class A
--// CS0121: The call is ambiguous between the following methods or properties: `V3.operator -(V3, V3)' and `V2.operator -(V2, V2)'
++// CS0121: The call is ambiguous between the following methods or properties: `V2.operator -(V2, V2)' and `V3.operator -(V3, V3)'
// Line: 45
public struct V3
--- /dev/null
--- /dev/null
++// CS0121: The call is ambiguous between the following methods or properties: `IList.Count()' and `ICounter.Count()'
++// Line: 29\r
++
++using System;
++
++interface IList \r
++{
++ int Count ();
++}
++
++interface ICounter \r
++{
++ int Count ();
++}\r
++\r
++interface ICollection\r
++{\r
++ int Count { set; }\r
++}
++
++interface IListCounter: IList, ICounter, ICollection\r
++{\r
++}
++
++class Test\r
++{
++ static void Foo (IListCounter t)
++ {
++ t.Count ();
++ }
++}
--// CS0122: `G.GG.F' is inaccessible due to its protection level
++// CS0122: `G.GG' is inaccessible due to its protection level
// Line: 14
class G
--// cs0146-3.cs: Circular base class dependency involving `Foo.Bar' and `Foo'
++// CS0146: Circular base class dependency involving `Foo' and `Foo.Bar'
// Line: 5
class Foo : Foo.Bar {
--// cs0146-4.cs: Circular base class dependency involving `Foo.Bar' and `Foo'
++// CS0146: Circular base class dependency involving `Baz' and `Foo.Bar'
// Line: 5
class Foo : Baz {
--// CS0278: `Testing.IMixedEnumerable' contains ambiguous implementation of `enumerable' pattern. Method `Testing.ICustomEnumerable.GetEnumerator()' is ambiguous with method `System.Collections.IEnumerable.GetEnumerator()'\r
++// CS0278: `Testing.IMixedEnumerable' contains ambiguous implementation of `enumerable' pattern. Method `System.Collections.IEnumerable.GetEnumerator()' is ambiguous with method `Testing.ICustomEnumerable.GetEnumerator()'\r
// Line: 28\r
// Compiler options: -warnaserror -warn:2\r
\r
foreach(object o in c) {}\r
}\r
}\r
--}
++}\r
--// cs0419-2.cs: Ambiguous reference in cref attribute `A.this'. Assuming `Test.A.this[string]' but other overloads including `Test.A.this[int]' have also matched
++// CS0419: Ambiguous reference in cref attribute `A.this'. Assuming `Test.A.this[int]' but other overloads including `Test.A.this[string]' have also matched
// Line: 7
// Compiler options: -doc:dummy.xml -warnaserror
using System.Collections;
--// CS0436: The type `System.Console' conflicts with the imported type `System.Console'. Ignoring the imported type definition
++// CS0436: The type `System.Console' conflicts with the imported type of same name'. Ignoring the imported type definition
// Line: 16
// Compiler options: -warn:2 -warnaserror
+++ /dev/null
--// cs0467-2.cs: Ambiguity between method `ICounter.Count()' and non-method `ICollection.Count'. Using method `ICounter.Count()'
--// Line: 30\r
--// Compiler options: -warnaserror -warn:2\r
--
--using System;
--
--interface IList \r
--{
-- int Count ();
--}
--
--interface ICounter \r
--{
-- int Count ();
--}\r
--\r
--interface ICollection\r
--{\r
-- int Count { set; }\r
--}
--
--interface IListCounter: IList, ICounter, ICollection\r
--{\r
--}
--
--class Test\r
--{
-- static void Foo (IListCounter t)
-- {
-- t.Count ();
-- }
--}
+++ /dev/null
--// cs0467-3.cs: Ambiguity between method `ICounter.Count()' and non-method `ICollection.Count'. Using method `ICounter.Count()'
--// Line: 34\r
--// Compiler options: -warnaserror -warn:2\r
--
--using System;
--
--interface IList \r
--{
-- int Count ();
--}
--
--interface ICounter \r
--{
-- int Count ();
--}\r
--\r
--interface ICollection\r
--{\r
-- int Count { set; }\r
--}
--
--interface IListCounter: IList, ICounter, ICollection\r
--{\r
--}\r
--\r
--interface IListCounterNew : IListCounter\r
--{\r
--}
--
--class Test\r
--{
-- static void Foo (IListCounterNew t)
-- {
-- t.Count ();
-- }
--}
+++ /dev/null
--// cs0467.cs: Ambiguity between method `ICounter.Count(int)' and non-method `IList.Count'. Using method `ICounter.Count(int)'
--// Line: 30\r
--// Compiler options: -warnaserror -warn:2\r
--
--using System;
--
--interface IList \r
--{
-- int Count { get; set; }
--}
--
--interface ICounter\r
--{\r
-- void Count (int i);
--}
--\r
--interface IEx\r
--{\r
-- void Count (params int[] i);\r
--}\r
--
--interface IListCounter: IEx, IList, ICounter\r
--{\r
--}
--
--class Test\r
--{
-- static void Foo (IListCounter t)
-- {
-- t.Count (1);
-- }
--}
--- /dev/null
--- /dev/null
++// CS0507: `DerivedClass.Message': cannot change access modifiers when overriding `public' inherited member `BaseClass.Message'
++// Line: 12
++
++class BaseClass {
++ public virtual string Message {
++ set {
++ }
++ }
++}
++
++class DerivedClass : BaseClass {
++ protected override string Message {
++ set {
++ }
++ }
++}
++
--// cs0527-2.cs: Type `A' in interface list is not an interface
--// Line: 7
++// CS0527: Type `B' in interface list is not an interface
++// Line: 4
struct A : B {
}
struct B : A {
--}
++}
--// cs0529.cs: Inherited interface `A' causes a cycle in the interface hierarchy of `C'
++// CS0529: Inherited interface `C' causes a cycle in the interface hierarchy of `A'
// Line: 10
interface A : B {
}
interface C : A {
--}
++}
--- /dev/null
--- /dev/null
++// CS0533: `DerivedClass.Foo' hides inherited abstract member `BaseClass.Foo()'
++// Line: 11
++
++abstract public class BaseClass
++{
++ abstract protected void Foo ();
++}
++
++abstract class DerivedClass: BaseClass
++{
++ public new int Foo;
++}
++
+++ /dev/null
--// cs0619-41.cs: `A.Filename' is obsolete: `Obsolete'
--// Line: 8
--
--class A: Error {
-- [System.ObsoleteAttribute ("Obsolete", true)]
-- public override string Filename {
-- set {
-- }
-- }
--
-- public static void Main () {}
--}
--
--public class Error {
-- public virtual string Filename {
-- set {
-- }
-- get {
-- return "aa";
-- }
-- }
--}
--
--class B {
-- void TT () {
-- new A ().Filename = "Filename";
-- }
--}
--// cs0683.cs: `C.I.set_Foo(int)' explicit method implementation cannot implement `I.Foo' because it is an accessor
++// CS0683: `C.I.set_Foo(int)' explicit method implementation cannot implement `I.Foo.set' because it is an accessor
// Line: 11
interface I
--// CS0738: `C' does not implement interface member `I2.Key.get' and the best implementing candidate `C.Key' return type `IB' does not match interface member return type `IA'
++// CS0738: `C' does not implement interface member `I2.Key.get' and the best implementing candidate `C.Key.get' return type `IB' does not match interface member return type `IA'
// Line: 22
public interface I1
--- /dev/null
--- /dev/null
++// CS0809: Obsolete member `A.Filename' overrides non-obsolete member `Error.Filename'
++// Line: 8
++// Compiler options: -warnaserror
++
++class A: Error {
++ [System.ObsoleteAttribute ("Obsolete", true)]
++ public override string Filename {
++ set {
++ }
++ }
++
++ public static void Main () {}
++}
++
++public class Error {
++ public virtual string Filename {
++ set {
++ }
++ get {
++ return "aa";
++ }
++ }
++}
++
++class B {
++ void TT () {
++ new A ().Filename = "Filename";
++ }
++}
--- /dev/null
--- /dev/null
++// CS1061: Type `A' does not contain a definition for `Foo' and no extension method `Foo' of type `A' could be found (are you missing a using directive or an assembly reference?)
++// Line: 17
++
++using System;
++using System.Runtime.CompilerServices;
++
++class A
++{
++ [IndexerName ("Foo")]
++ public int this [int index] {
++ get { return index; }
++ set { ; }
++ }
++
++ static void Test (A a, int value)
++ {
++ a.Foo = value;
++ }
++
++ public static void Main ()
++ {
++ Test (new A (), 9);
++ }
++}
--- /dev/null
--- /dev/null
++// CS1061: Type `A' does not contain a definition for `Foo' and no extension method `Foo' of type `A' could be found (are you missing a using directive or an assembly reference?)
++// Line: 16
++
++using System;
++using System.Runtime.CompilerServices;
++
++class A
++{
++ [IndexerName ("Foo")]
++ public int this [int index] {
++ get { return index; }
++ }
++
++ static int Test (A a)
++ {
++ return a.Foo;
++ }
++
++ public static void Main ()
++ {
++ Test (new A ());
++ }
++}
--// cs1546.cs: Property `Title' is not supported by the C# language. Try to call the accessor method `Test.ITopic.get_Title(int, int)' directly
++// CS1546: Property or event `Test.ITopic.Title' is not supported by the C# language
// Line: 9
// Compiler options: -r:CS1546-lib.dll
--// CS1685: The predefined type `System.Int32' is ambiguous. Using definition from `mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
++// CS1685: The predefined type `System.Int32' is redefined in the source code. Ignoring the local type definition
// Line: 6
// Compiler options: -warn:1 -warnaserror
--// CS1739: The best overloaded method match for `A.this[int]' does not contain a parameter named `value'
++// CS1739: The best overloaded method match for `A.this[int].set' does not contain a parameter named `value'
// Line: 17
--// Compiler options: -langversion:future
class A
{
--// cs3005-2.cs: Identifier `CLSClass.Index' differing only in case is not CLS-compliant
++// CS3005: Identifier `CLSClass.Index.get' differing only in case is not CLS-compliant
// Line: 14
// Compiler options: -warnaserror
--// CS3005: Identifier `I.this[int]' differing only in case is not CLS-compliant
--// Line: 12
++// CS3005: Identifier `I.BLAH.get' differing only in case is not CLS-compliant
++// Line: 16
// Compiler options: -warnaserror
using System.Runtime.CompilerServices;
--// CS0108: `BaseConcrete.InnerDerived<T>()' hides inherited member `BaseGeneric<T>.InnerDerived'. Use the new keyword if hiding was intended
++// CS0108: `BaseConcrete.InnerDerived<T>()' hides inherited member `BaseGeneric<string>.InnerDerived'. Use the new keyword if hiding was intended
// Line: 14
// Compiler options: -warn:2 -warnaserror
--// CS0122: `Test<A>' is inaccessible due to its protection level
++// CS0122: `Test<float>' is inaccessible due to its protection level
// Line: 8
// Compiler options: -r:GCS0122-2-lib.dll
--// gcs0146.cs: Circular base class dependency involving `B<T>' and `A<T>'
++// CS0146: Circular base class dependency involving `B<T>' and `A<float>'
// Line: 8
class A<T> : B<int>
+++ /dev/null
--// gcs0246.cs: The type or namespace name `List`2' could not be found. Are you missing a using directive or an assembly reference?
--// Line: 8
--
--using System.Collections.Generic;
--
--class X
--{
-- List<int,long> list;
--}
--- /dev/null
--- /dev/null
++// CS0246: The type or namespace name `X' could not be found. Are you missing a using directive or an assembly reference?
++// Line: 4
++
++class A<T> where T : X
++{
++ public class X {}
++}
--- /dev/null
--- /dev/null
++// CS0246: The type or namespace name `M' could not be found. Are you missing a using directive or an assembly reference?
++// Line: 11
++
++interface I<T>
++{
++ void G<TT> ();
++}
++
++class C
++{
++ void I<M>.G<M> ()
++ {
++ }
++
++ public static void Main ()
++ {
++ }
++}
--// gcs0246.cs: The type or namespace name `NotExist`1' could not be found. Are you missing a using directive or an assembly reference?
++// CS0246: The type or namespace name `NotExist' could not be found. Are you missing a using directive or an assembly reference?
// Line: 6
class X
--// CS0304: Cannot create an instance of the variable type 'T' because it doesn't have the new() constraint
--// Line: 9
++// CS0304: Cannot create an instance of the variable type `T' because it does not have the new() constraint
++// Line: 8
public class Foo<T>
{
--- /dev/null
--- /dev/null
++// CS0305: Using the generic type `System.Collections.Generic.List<T>' requires `1' type argument(s)
++// Line: 8
++
++using System.Collections.Generic;
++
++class X
++{
++ List<int,long> list;
++}
+++ /dev/null
--// CS0309: The type `B' must be convertible to `I' in order to use it as parameter `T' in the generic type or method `Foo<T>'
--// Line: 21
--
--public class Foo<T>
-- where T : A, I
--{
--}
--
--public interface I
--{ }
--
--public class A
--{ }
--
--public class B : A
--{ }
--
--class X
--{
-- Foo<B> foo;
--
-- static void Main ()
-- {
-- }
--}
+++ /dev/null
--// CS0309: The type `B' must be convertible to `A' in order to use it as parameter `T' in the generic type or method `Foo<T>'
--// Line: 35
--using System;
--
--public class Foo<T>
-- where T : A
--{
-- public void Test (T t)
-- {
-- Console.WriteLine (t);
-- Console.WriteLine (t.GetType ());
-- t.Hello ();
-- }
--}
--
--public class A
--{
-- public void Hello ()
-- {
-- Console.WriteLine ("Hello World");
-- }
--}
--
--public class B
--{
-- public static implicit operator A (B b)
-- {
-- return new A ();
-- }
--}
--
--class X
--{
-- Foo<B> b;
--
-- static void Main ()
-- {
-- }
--}
+++ /dev/null
-- // gcs0309.cs: The type `U' must be convertible to `System.IComparable' in order to use it as parameter `T' in the generic type or method `A<T>'
--// Line: 13
--
--using System;
--
--class A<T>
-- where T: IComparable
--{
--}
--
--class B<U,V>
-- where V: A<U>
--{
--}
--
--class Driver
--{
-- public static void Main ()
-- {
-- }
--}
+++ /dev/null
--// CS0309: The type `int' must be convertible to `System.EventArgs' in order to use it as parameter `TEventArgs' in the generic type or method `System.EventHandler<TEventArgs>'
--// Line: 5
--
--class X {
-- System.EventHandler <int> x;
-- static void Main () {}
--}
--
--
+++ /dev/null
--// CS0309: The type `B<int>' must be convertible to `D<B<int>>' in order to use it as parameter `X' in the generic type or method `C<X>'
--// Line: 3
--class A : C<B<int>> {}
--class B<X> {}
--interface C<X> where X : D<X> {}
--interface D<X> {}
+++ /dev/null
--// CS0309: The type `T' must be convertible to `System.IDisposable' in order to use it as parameter `T' in the generic type or method `IB<K,T>'
--// Line: 20
--
--public interface IA<K>
-- where K : System.IComparable, System.IComparable<K>
--{
--}
--
--public class A<K> : IA<K>
-- where K : System.IComparable, System.IComparable<K>
--{
--}
--
--public interface IB<K,T>
-- where T : System.IDisposable
--{
--}
--
--public class B<K,T> : IB<K,T>
-- where T : B<K,T>.Element, new()
-- where K : System.IComparable, System.IComparable<K>
--{
-- public abstract class Element : A<K>
-- {
-- }
--}
--
--
--
--
+++ /dev/null
--// CS0309: The type `B' must be convertible to `A' in order to use it as parameter `T' in the generic type or method `Foo<T>'
--// Line: 20
--
--public class Foo<T>
-- where T : A
--{
--}
--
--public class A
--{
--}
--
--public class B
--{
--}
--
--class X
--{
-- Foo<B> foo;
--
-- static void Main ()
-- {
-- }
--}
--- /dev/null
--- /dev/null
++// CS031: The type `B' cannot be used as type parameter `T' in the generic type or method `Foo<T>'. There is no implicit reference conversion from `B' to `I'
++// Line: 21
++
++public class Foo<T>
++ where T : A, I
++{
++}
++
++public interface I
++{ }
++
++public class A
++{ }
++
++public class B : A
++{ }
++
++class X
++{
++ Foo<B> foo;
++
++ static void Main ()
++ {
++ }
++}
--- /dev/null
--- /dev/null
++// CS0311: The type `B' cannot be used as type parameter `T' in the generic type or method `Foo<T>'. There is no implicit reference conversion from `B' to `A'
++// Line: 35
++using System;
++
++public class Foo<T>
++ where T : A
++{
++ public void Test (T t)
++ {
++ Console.WriteLine (t);
++ Console.WriteLine (t.GetType ());
++ t.Hello ();
++ }
++}
++
++public class A
++{
++ public void Hello ()
++ {
++ Console.WriteLine ("Hello World");
++ }
++}
++
++public class B
++{
++ public static implicit operator A (B b)
++ {
++ return new A ();
++ }
++}
++
++class X
++{
++ Foo<B> b;
++
++ static void Main ()
++ {
++ }
++}
--- /dev/null
--- /dev/null
++// CS0311: The type `B<int>' cannot be used as type parameter `X' in the generic type or method `C<X>'. There is no implicit reference conversion from `B<int>' to `D<B<int>>'
++// Line: 3
++class A : C<B<int>> {}
++class B<X> {}
++interface C<X> where X : D<X> {}
++interface D<X> {}
--- /dev/null
--- /dev/null
++// CS0311: The type `B' cannot be used as type parameter `T' in the generic type or method `Foo<T>'. There is no implicit reference conversion from `B' to `A'
++// Line: 19
++
++public class Foo<T>
++ where T : A
++{
++}
++
++public class A
++{
++}
++
++public class B
++{
++}
++
++class X
++{
++ Foo<B> foo;
++
++ static void Main ()
++ {
++ }
++}
--// CS0313: The type `S?' cannot be used as type parameter `T' in the generic type or method `S.Foo<T>(T)'. The nullable type `S?' never satisfies interface constraint of type `I'
++// CS0313: The type `S?' cannot be used as type parameter `T' in the generic type or method `S.Foo<T>(T)'. The nullable type `S?' never satisfies interface constraint
// Line: 16
interface I
--- /dev/null
--- /dev/null
++// CS0314: The type `T' cannot be used as type parameter `T' in the generic type or method `IB<K,T>'. There is no boxing or type parameter conversion from `T' to `System.IDisposable'
++// Line: 20
++
++public interface IA<K>
++ where K : System.IComparable, System.IComparable<K>
++{
++}
++
++public class A<K> : IA<K>
++ where K : System.IComparable, System.IComparable<K>
++{
++}
++
++public interface IB<K,T>
++ where T : System.IDisposable
++{
++}
++
++public class B<K,T> : IB<K,T>
++ where T : B<K,T>.Element, new()
++ where K : System.IComparable, System.IComparable<K>
++{
++ public abstract class Element : A<K>
++ {
++ }
++}
++
++
++
++
--- /dev/null
--- /dev/null
++// CS0314: The type `U' cannot be used as type parameter `T' in the generic type or method `A<T>'. There is no boxing or type parameter conversion from `U' to `System.IComparable'
++// Line: 13
++
++using System;
++
++class A<T>
++ where T: IComparable
++{
++}
++
++class B<U,V>
++ where V: A<U>
++{
++}
++
++class Driver
++{
++ public static void Main ()
++ {
++ }
++}
--- /dev/null
--- /dev/null
++// CS0315: The type `int' cannot be used as type parameter `TEventArgs' in the generic type or method `System.EventHandler<TEventArgs>'. There is no boxing conversion from `int' to `System.EventArgs'
++// Line: 5
++
++class X {
++ System.EventHandler <int> x;
++ static void Main () {}
++}
++
++
--- /dev/null
--- /dev/null
++// CS0411: The type arguments for method `C.Foo<T>(T, System.Collections.Generic.Comparer<T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly
++// Line: 20
++
++using System;
++using System.Collections.Generic;
++
++public class C
++{
++ static void Foo<T>(T t, Comparer<T> tc)
++ {
++ }
++
++ static int Compare (int a, int b)
++ {
++ return -1;
++ }
++
++ public static void Main ()
++ {
++ Foo (1, Compare);
++ }
++}
--- /dev/null
--- /dev/null
++// CS0425: The constraints for type parameter `V' of method `Foo<T,X>.Test<V>()' must match the constraints for type parameter `U' of interface method `IFoo<T>.Test<U>()'. Consider using an explicit interface implementation instead
++// Line: 11
++
++interface IFoo<T>
++{
++ void Test<U> () where U : T;
++}
++
++class Foo<T, X> : IFoo<T>
++{
++ public void Test<V> () where V : X
++ {
++ }
++}
--- /dev/null
--- /dev/null
++// CS0455: Type parameter `T' inherits conflicting constraints `System.ValueType' and `Test'
++// Line: 8
++
++class Test
++{ }
++
++class Foo<T,U>
++ where T : struct, U
++ where U : Test
++{ }
// CS0455: Type parameter `T' inherits conflicting constraints `Test' and `World'
--// Line: 13
--using System;
++// Line: 11
class Test
{ }
where T : Test, U
where U : World
{ }
--
--class X
--{
-- static void Main ()
-- { }
--}
--// gcs0689.cs: Cannot derive from `T' because it is a type parameter
++// CS0689: `Stack<T>': Cannot derive from type parameter `T'
// Line: 4
class Stack<T> : T { }
--// gcs0695.cs: `A<X,Y,Z>' cannot implement both `I<A<Y,Y,Z>>' and `I<X>' because they may unify for some type parameter substitutions
++// CS0695: `A<X,Y,Z>' cannot implement both `I<X>' and `I<A<Y,Y,Z>>' because they may unify for some type parameter substitutions
// Line: 7
interface I<X>
--// gcs0695.cs: `C<X,Y>' cannot implement both `I<K<Y>>' and `I<X>' because they may unify for some type parameter substitutions
++// CS0695: `C<X,Y>' cannot implement both `I<X>' and `I<K<Y>>' because they may unify for some type parameter substitutions
// Line: 10
interface I<X>
--// gcs0695.cs: `C<X,Y>' cannot implement both `I<X>' and `I<K<Y>>' because they may unify for some type parameter substitutions
++// CS0695: `C<X,Y>' cannot implement both `I<K<Y>>' and `I<X>' because they may unify for some type parameter substitutions
// Line: 10
interface I<X>
--// gcs0695.cs: `A<X,Y>' cannot implement both `I<Y>' and `I<X>' because they may unify for some type parameter substitutions
++// CS0695: `A<X,Y>' cannot implement both `I<X>' and `I<Y>' because they may unify for some type parameter substitutions
// Line: 7
interface I<X>
--// CS0703: Inconsistent accessibility: constraint type `C.I' is less accessible than `Foo<T>()'
++// CS0703: Inconsistent accessibility: constraint type `C.I' is less accessible than `C.Foo<T>()'
// Line: 10
public class C
--// CS1502: The best overloaded method match for `A.A(System.Collections.Generic.IList<System.Collections.Generic.IList<int>>)' has some invalid arguments
++// CS1502: The best overloaded method match for `A.A(System.Collections.Generic.IList<int>[])' has some invalid arguments
// Line: 40
using System;
using System.Collections;
+++ /dev/null
--// CS1503: Argument `#2' cannot convert `method group' expression to type `System.Collections.Generic.Comparer<int>'
--// Line: 20
--
--using System;
--using System.Collections.Generic;
--
--public class C
--{
-- static void Foo<T>(T t, Comparer<T> tc)
-- {
-- }
--
-- static int Compare (int a, int b)
-- {
-- return -1;
-- }
--
-- public static void Main ()
-- {
-- Foo (1, Compare);
-- }
--}
--// CS1640: foreach statement cannot operate on variables of type `T' because it contains multiple implementation of `System.Collections.Generic.IEnumerable<T>.GetEnumerator()'. Try casting to a specific implementation\r
++// CS1640: foreach statement cannot operate on variables of type `T' because it contains multiple implementation of `System.Collections.Generic.IEnumerable<T>'. Try casting to a specific implementation\r
// Line: 11\r
\r
using System.Collections.Generic;\r
--// CS1961: The covariant type parameter `V' must be contravariantly valid on `Foo<T>(T)'
++// CS1961: The covariant type parameter `V' must be contravariantly valid on `I<V>.Foo<T>(T)'
// Line: 6
interface I<out V>
--- /dev/null
--- /dev/null
++// CS3005: Identifier `CLSClass.Method<T>(int)' differing only in case is not CLS-compliant
++// Line: 12
++// Compiler options: -warnaserror
++
++[assembly:System.CLSCompliant (true)]
++
++public class BaseClass {
++ public int method;
++}
++
++public class CLSClass : BaseClass {
++ public static void Method<T>(int arg) {}
++}
--- /dev/null
--- /dev/null
++// CS3009: `C': base type `C<ulong>' is not CLS-compliant
++// Line: 14
++// Compiler options: -warnaserror -warn:1
++
++using System;
++[assembly:CLSCompliant(true)]
++
++public class C<T>
++{
++}
++
++public class C : C<ulong>
++{
++}
projects / mono.git / commitdiff