<?xml version="1.0"?>
<ErrorDocumentation xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <ErrorName>CS0019</ErrorName>
  <Examples>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `int' and `S?'
// Line: 15

struct S
{
	public static bool operator !=(int a, S s) { return true; }
	public static bool operator ==(int a, S s) { return false; }
}

public class C
{
	public static void Main ()
	{
		S? s;
		var b = 1 == s;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `C.E1' and `C.E2'
// Line: 21

class C
{
	enum E1 : long
	{
		A
	}
	
	enum E2 : sbyte
	{
		A
	}
	
	public static void Main ()
	{
		E1 b = E1.A;
		E2 d = E2.A;
		
		bool brr = b == d;
	}
}
</string>
    <string>// CS0019: Operator `??' cannot be applied to operands of type `null' and `bool'
// Line: 8

class Program
{
	static void Main()
	{
		object s = null ?? true;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `dynamic' and `method group'
// Line: 9

class C
{
	static void Main ()
	{
		dynamic x = null;
		var y = x == Main;
	}
}
</string>
    <string>// CS0019: Operator `&gt;' cannot be applied to operands of type `S' and `S?'
// Line: 9

public class Test
{
	public static void Main ()
	{
		S a = new S ();
		S? b = null;
		string res = a &gt; b;
	}
}

struct S
{
	public static string operator &gt; (S a, S b)
	{ 
		return "&gt;";
	}
	
	public static string operator &lt; (S a, S b)
	{ 
		return "&lt;";
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `dynamic' and `void'
// Line: 9

class C
{
	static void Main ()
	{
		dynamic x = null;
		var y = x == Main ();
	}
}
</string>
    <string>// CS0019: Operator `-' cannot be applied to operands of type `A' and `B'
// Line : 20

enum A
{
        A1,
        A2
}

enum B
{
        B1,
        B2
}

class C
{
        static void Main ()
        {
                System.Console.WriteLine (A.A1 - B.B1);
        }
}
</string>
    <string>// CS0019: Operator `-' cannot be applied to operands of type `AA' and `long'
// Line: 11

enum AA : short { a, b = 200 }

public class C
{
	public static void Main ()
	{
		const long ul = 1;
		AA b = AA.a - ul;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `object' and `V'
// Line: 9

public class C&lt;V&gt;
{
	public bool TryGet (V v)
	{
		object tmp = null;
		return tmp == v;
	}
}
</string>
    <string>// CS0019: Operator `&gt;=' cannot be applied to operands of type `ulong' and `sbyte'
// Line: 7

class X {
	bool ret (ulong u, sbyte s)
	{
		return (u &gt;= s);
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `X' and `Y'
// Line : 13

class X {
}

class Y {
}

class T {
	static void Main ()
	{
		X x = new X ();
		Y y = new Y ();

		if (x == y){
		}
	}
}
</string>
    <string>// CS0019: Operator `&amp;&amp;' cannot be applied to operands of type `bool' and `null'
// Line: 14

class C
{
	public static void Main ()
	{
		bool b = true;
		b = b &amp;&amp; null;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `T' and `T'
// Line: 5
public class TestClass&lt;T&gt;
{
	public bool Check (T x, T y) { return x == y; }
}

public class X
{
	static void Main ()
	{ }
}


</string>
    <string>// CS0019: Operator `&amp;&amp;' cannot be applied to operands of type `bool?' and `bool?'
// Line: 10
using System;

class X
{
	static void Main ()
	{
		bool? a = false, b = false;
		Console.WriteLine (a &amp;&amp; b);
	}
}
</string>
    <string>// CS0019: Operator `??' cannot be applied to operands of type `null' and `anonymous method' 
// Line: 8

delegate void D ();

class F
{
	D d = null ?? delegate { };
}
</string>
    <string>// CS0019: Operator `&amp;=' cannot be applied to operands of type `bool' and `byte?'
// Line: 10

public class Test
{
	public static void Main()
	{
		bool b = false;
		byte? b2 = 0;
		b &amp;= b2;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `S' and `S'
// Line: 22

struct S
{
	public static implicit operator E (S s)
	{
		return 0;
	}
}

public enum E
{
}

class C
{
	public static void Main ()
	{
		S s;
		S s2;
		var x = s == s2;
	}
}</string>
    <string>// CS0019: Operator `-' cannot be applied to operands of type `ulong' and `sbyte'
// Line: 6

class S
{
	const ulong u = (ulong)0 - (sbyte)1;
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `method group' and `null'
// Line: 8

public class C
{
	public static void Main ()
	{
		bool a = DelegateMethod == null;
	}

	static int DelegateMethod(bool b)
	{
		return 3;
	}	
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `S' and `S'
// Line: 14

struct S
{
}

class C
{
	public static void Main ()
	{
		S s;
		S x;
		bool b = s == x;
	}
}
</string>
    <string>// CS0019: Operator `&amp;' cannot be applied to operands of type `System.Reflection.MethodImplAttributes' and `System.Runtime.CompilerServices.MethodImplOptions'
// Line : 13

//
// From bug #59864 
//
using System.Reflection;
using System.Runtime.CompilerServices;

public class Foo {

	public static void Main ()
	{
		MethodImplAttributes methodImplAttributes = 0;
            
                if ((methodImplAttributes &amp; MethodImplOptions.Synchronized) == 0) {
                }
	}
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `method group' and `method group'
// Line: 10

using System;

public class Test
{
	public static void Main ()
	{
		Console.WriteLine (Main + Main);
	}
}
</string>
    <string>// CS0019:  Operator `==' cannot be applied to operands of type `object' and `int'
// Line: 11

using System;

class Test {

	static void Main ()
	{
		object o = 2;
		if (o == 42)
			Console.WriteLine (o);
	}
}
</string>
    <string>// CS0019: Operator `%' cannot be applied to operands of type `E' and `int'
// Line : 10

enum E: byte {
	Min
}

class T {
	static void Main () {
		E error = E.Min % 2;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `bool' and `int'
// Line: 10

class C
{
	static bool HasSessionId (string path)
	{
		if (path == null || path.Length &lt; 5)
			return false;

		return path.StartsWith ("/(") == 0;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `A' and `int?'
// Line: 22

class A
{
	public static bool operator == (A a, int b)
	{
		return false;
	}
	
	public static bool operator != (A a, int b)
	{
		return false;
	}
}

class C
{
	public static void Main ()
	{
		A a = new A ();
		object b = a == Id;
	}
	
	static int? Id {
		get { return 1; }
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `anonymous method' and `anonymous method'
// Line: 8

public class C
{
	public static void Main ()
	{
		bool b = delegate () {} == delegate () {};
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `Foo' and `null'
// Line: 14

struct Foo
{
	public static bool operator == (int d1, Foo d2)
	{
		throw new System.ApplicationException ();
	}
		
	public static bool operator != (int d1, Foo d2)
	{
		throw new System.ApplicationException ();	
	}
}

public class Test
{
	static Foo ctx;

	public static void Main ()
	{
		if (ctx == null)
			return;
	}
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `Program' and `Program'
// Line: 8

public class Program
{
	static void Main ()
	{
		Program b = default (Program) + default (Program);
	}
}
</string>
    <string>// CS0019: Operator `&gt;=' cannot be applied to operands of type `ulong' and `short'
// Line: 7

class X {
	bool ret (ulong u, short s)
	{
		return (u &gt;= s);
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `S?' and `int'
// Line: 15

struct S
{
	public static bool operator != (S s, int a) { return true; }
	public static bool operator == (S s, int a) { return false; }
}

public class C
{
	public static void Main ()
	{
		S? s;
		var b = s == 1;
	}
}
</string>
    <string>// CS0019: Operator `-' cannot be applied to operands of type `string' and `ulong'
// Line : 12

using System;

public class C
{
    public static void Main ()
    {
        ulong aa = 10;
        ulong bb = 3;
        Console.WriteLine("bug here --&gt; "+aa-bb);
    }
}
</string>
    <string>// CS0019: Operator `??' cannot be applied to operands of type `int' and `int'
// Line: 8
class X
{
	static void Main ()
	{
		int a = 5;
		int b = a ?? 3;
	}
}
</string>
    <string>// CS0019: Operator `+=' cannot be applied to operands of type `dynamic' and `anonymous method'
// Line: 9

class MainClass
{
	public static void Main ()
	{
		dynamic d = null;
		d += delegate {};
	}
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `Foo' and `int'
// Line : 9

public class Foo
{
	public static void Main ()
	{
		Foo k = new Foo ();
		int i = k + 6;
	}
}
</string>
    <string>// CS0019: Operator `!=' cannot be applied to operands of type `ulong?' and `int' 
// Line: 8

class C
{
	static void Test (ulong? x, int y)
	{
		if (x != y)
		{
		}
	}
}
</string>
    <string>// CS0019: Operator `^' cannot be applied to operands of type `S2' and `float'
// Line: 9

public class Test
{
	public static void Main()
	{
		S2 s2 = new S2 ();
		int r = s2 ^ 5.04f;
	}
}

struct S2
{
	public static int operator ^ (double? p1, S2 s2)
	{
		return 1;
	}
	
	public static implicit operator int? (S2 s1)
	{ 
		return int.MinValue;
	}
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `Test.Zub' and `Test.Zub'
// Line : 11
using System;

class Test {

	enum Zub :byte {
		Foo = 99,
		Bar,
		Baz
	}
	

	static void Main ()
	{
		object v = (Zub.Foo + Zub.Foo);
	}
}
	
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `string' and `float*'
// Line: 12
// Compiler options: -unsafe
using System;

public class Driver {
  public static void Main () {
    float [] floats = new float[1];
    floats[0] = 1.0f;
    unsafe {
      fixed (float *fp = &amp;floats[0]) {
      Console.WriteLine ("foo" + fp);
      }
    }
  }
}
</string>
    <string>// CS0019: Operator `&amp;' cannot be applied to operands of type `C.Flags' and `int'
// Line: 16

using System;

class C
{
	enum Flags {
		Removed	= 0
	}
	
	public int	_enumFlags;
		
	internal void Close()
	{	
		if ((Flags.Removed &amp; _enumFlags) == Flags.Removed)
			Console.WriteLine ("error");
	}
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `AA' and `uint'
// Line: 11

enum AA : byte { a, b = 200 }

public class C
{
	public static void Main ()
	{
		const uint ul = 1;
		AA b = AA.a + ul;
	}
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `int' and `Test.Zub'
// Line : 11
using System;

class Test {

	enum Zub :byte {
		Foo = 99,
		Bar,
		Baz
	}
	

	static void Main ()
	{
		int v = 1;
		object foo = (v + Zub.Foo);
	}
}
	
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `T' and `U'
// Line: 12

interface I
{
}

class Program
{
	bool Test&lt;T, U&gt; (T t, U u) where T : I where U : I
	{
		return t == u;
	}
}
</string>
    <string>// CS0019: Operator `!=' cannot be applied to operands of type `Test.DelegateA' and `Test.DelegateB'
// Line: 13

using System;

public class Test
{
	public delegate int DelegateA(bool b);
	public delegate int DelegateB(bool b);

	static bool TestCompare (DelegateA a, DelegateB b)
	{
		return a != b;
	}
}
</string>
    <string>// CS0019: Operator `??' cannot be applied to operands of type `null' and `method group'
// Line: 8

class C
{
	delegate void D ();

	static void Main ()
	{
		D d = null ?? Main;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `int' and `string'
// Line: 8

class S
{
	static int i;
	
	static bool Foo ()
	{
		return i == "";
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `void' and `null'
// Line: 11

using System;

class C
{
	public static void Main ()
	{
		Action a = () =&gt; {};
		bool b = a () == null;
	}
}
</string>
    <string>// CS0019: Operator `*' cannot be applied to operands of type `E' and `E'
// Line : 10

enum E: byte {
	Min
}

class T {
	static void Main () {
		E error = E.Min * E.Min;
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `dynamic' and `anonymous method'
// Line: 9

class C
{
	static void Main ()
	{
		dynamic x = null;
		var y = x == (() =&gt; 1);
	}
}
</string>
    <string>// CS0019: Operator `+=' cannot be applied to operands of type `object' and `object'
// Line: 10

class Program
{
	static int Main ()
	{
		object[] o = null;
		int ii = 2;
		o [ii++] += new object ();
		return 0;
	}
}
</string>
    <string>// CS0019: Operator `??' cannot be applied to operands of type `T' and `T' 
// Line: 8

class F
{
	T Bar&lt;T&gt; (T t)
	{
		return t ?? default(T);
	}
}
</string>
    <string>// CS0019: Operator `!=' cannot be applied to operands of type `method group' and `string'
// Line: 20

namespace InternalAccess
{
	public abstract class Base
	{
		internal string Prop () { return "a"; }
	}

	public class DerivedProtectedExample : Base
	{
		protected new string Prop { get { return "E"; } }
	}

	class MainClass
	{
		public static int Main ()
		{
			DerivedProtectedExample dpe = new DerivedProtectedExample ();
			if (dpe.Prop != "A")
				return 2;

			return 0;
		}
	}
}
</string>
    <string>// CS0019: Operator `&lt;&lt;' cannot be applied to operands of type `byte' and `uint'
// Line: 9

using System;
public class PerformanceTest2 {
	public static void Main () {
		uint j, k;
		j = 0;
		k = ((byte) 1 &lt;&lt; (7 - j % 8));
	}
}
</string>
    <string>// CS0019: Operator `&amp;&amp;' cannot be applied to operands of type `S?' and `S?'
// Line: 20

struct S
{
	public static S operator &amp; (S s, S i)
	{
		return s;
	}
}

class C
{
	public static void Main ()
	{
		S? s = new S ();
		S? s2 = null;

		var res = s &amp;&amp; s2;
	}
}</string>
    <string>// CS0019: Operator `??' cannot be applied to operands of type `void' and `throw expression'
// Line: 20

class C
{
	public static void Main ()
	{
		var s = Main () ?? throw null;
	}
}</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `method group' and `method group'
// Line: 8

public class C
{
	public static void Main ()
	{
		bool a = DelegateMethod == DelegateMethod;
	}

	static int DelegateMethod(bool b)
	{
		return 3;
	}	
}
</string>
    <string>// CS0019: Operator `&gt;&gt;' cannot be applied to operands of type `E' and `int'
// Line : 10

enum E: byte {
	Min
}

class T {
	static void Main () {
		E error = E.Min &gt;&gt; 2;
	}
}
</string>
    <string>// CS0019: Operator `|' cannot be applied to operands of type `E' and `int'
// Line: 10

enum E: byte {
	Min
}

class T {
	static void Main () {
		E error = E.Min | 4;
	}
}
</string>
    <string>// CS0019: Operator `-' cannot be applied to operands of type `float' and `decimal'
// Line: 6

class S
{
	const decimal d = 0f - 1m;
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `A' and `B'
// Line : 21

enum A
{
        A1,
        A2
}

enum B
{
        B1,
        B2
}

class C
{
        static void Main ()
        {
                A a = A.A1;
                System.Console.WriteLine (a == B.B1);
        }
}
</string>
    <string>// CS0019: Operator `&gt;' cannot be applied to operands of type `bool' and `bool'
// Line: 6

class S
{
	const bool res = true &gt; false;
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `string' and `method group'
// Line: 10

using System;

public class Test
{
	public static void Main ()
	{
		Console.WriteLine ("+++" + Main);
	}
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `Test.Zub' and `Test.Zub'
// Line : 11
using System;

class Test {

	enum Zub :byte {
		Foo = 99,
		Bar,
		Baz
	}
	

	static void Main ()
	{
		Zub a = Zub.Foo, b = Zub.Bar;
		object v = (a + b);
	}
}
	
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `string' and `method group'
// Line: 11

using System;

class MainClass
{
	public static void Main (string[] args)
	{
		foreach (object at in args) {
			Console.WriteLine ("Tipo attributo: " + at.GetType);
		}
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `External' and `int'
// Line: 11
// Compiler options: -r:CS0019-71-lib.dll

class X
{
	public static void Main ()
	{
		var t1 = new External ();
		int t2 = 0;
		bool b = t1 == t2;
	}
}</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `A.D' and `anonymous method'
// Line: 11

class A
{
	delegate void D ();

	static void Main ()
	{
		D d = null;
		bool r = d == (() =&gt; { });
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `Foo' and `null'
// Line: 14

struct Foo
{
}

public class Test
{
	static Foo ctx;

	public static void Main ()
	{
		if (ctx == null)
			return;
	}
}
</string>
    <string>// CS0019: Operator `&amp;&amp;' cannot be applied to operands of type `null' and `null'
// Line : 8

public class C
{
    public static void Main()
    {
        bool l = (null &amp;&amp; null);
    }
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `U' and `null'
// Line: 13

abstract class A&lt;T&gt;
{
	public abstract bool Foo&lt;U&gt; (U arg) where U : T;
}

class B : A&lt;byte&gt;
{
	public override bool Foo&lt;U&gt; (U arg)
	{
		return arg == null;
	}
}
</string>
  </Examples>
</ErrorDocumentation>