<?xml version="1.0"?>
<ErrorDocumentation xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <ErrorName>CS0029</ErrorName>
  <Examples>
    <string>// CS0029: Cannot implicitly convert type `bool' to `int'
// Line : 7

class T {
	static int Main ()
	{
		int a = default(bool);
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `double'
// Line: 11

using System;

public sealed class BoundAttribute : System.Attribute
{
	public double D;
}

class C
{
	[Bound (D = "Dude!")]
	double d2;
}</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `int'
// Line: 28


delegate string funcs (string s);
delegate int funci (int i);

class X
{
	static void Foo (funci fi)
	{
	}
	
	static void Foo (funcs fs)
	{
	}

	static void Main ()
	{
		Foo (x =&gt; {
			int a = "a";
			return 2;
		});
	}
}</string>
    <string>// CS0029: Cannot implicitly convert type `T[]' to `System.Collections.Generic.IList&lt;U&gt;'
// Line: 10

using System.Collections.Generic;

class Program
{
	static IList&lt;U&gt; Foo&lt;T, U&gt; (T[] arg) where T : U
	{
		return arg;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `T' to `int*'
// Line: 8
// Compiler options: -unsafe

class T
{
	static unsafe void Main ()
	{
		int* a = default (T);
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `T[]' to `I[]'
// Line: 12

interface I
{
}

class C
{
	static void Foo&lt;T&gt; (T [] t) where T : I
	{
		I [] i = t;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `void' to `object'
// Line: 12

using System;
using System.Collections;

public class Test
{
	static void Main ()
	{
		Hashtable ht = new Hashtable ();
		ht ["a"] = Run ("Appointments");
	}

	public static void Run (string unit)
	{
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `T2' to `T1'
// Line: 8

class Test
{
	static void Foo&lt;T1, T2&gt; (T1 t1, T2 t2)
	{
		T1 a = default (T2);
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `T' to `int*'
// Line : 8
// Compiler options: -unsafe

class T {
	static unsafe void Main ()
	{
		int *a = default(T);
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `B [cs0029-26, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null -- *PATH*/cs0029-26.cs]' to `B [CS0029-26-lib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=36f3ae7e947792e3 -- *PATH*/CS0029-26-lib.dll]'
// Line: 16
// Compiler options: -r:R1=CS0029-26-lib.dll

extern alias R1;

public class B
{
}

public class C
{
	public static void Main ()
	{
		B b1 = null;
		R1::B b2 = b1;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `int'
// Line : 7

public class Blah {

	public enum MyEnum {
		Foo = "foo",
		Bar
	}

	public static void Main ()
	{
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `int'
// Line: 11

using System;
using System.Threading.Tasks;

class C
{
	public async Task&lt;int&gt; Test ()
	{
		return await Call ();
	}
	
	Task&lt;string&gt; Call ()
	{
		return null;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `int'
// Line: 8

class C
{
	void Exists (int _)
	{
		_ = "2";
	}	
}</string>
    <string>// CS0029: Cannot implicitly convert type `X' to `bool'
// Line : 11

class X {
}

class T {
	static void Main ()
	{
		X x = new X ();
		if (x){
		}
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `S' to `System.ValueType'
// Line: 16
// Compiler options: -langversion:latest

using System;

public ref struct S
{
}

class Test
{
	public static void Main ()
	{
		var s = default (S);
		ValueType s2 = s;
		var res = default (S).ToString ();
	}
}</string>
    <string>// CS0029: Cannot implicitly convert type `T' to `int'
// Line: 4

class X {
	static void Main()
	{
		int a = new T ();
	}
}

struct T {
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `Test.String'
// Line: 38

using System;

namespace Test
{
	using Text = System.Text;
	using Str = System.String;
	
	public class String
	{
		string s;
		public String(string s)
		{
			this.s=s;
		}

		public static implicit operator Str (String s1) 
		{
			if(s1==null) return null;
			return s1.ToString();
		}
	}
}

namespace TestCompiler
{
	using String=Test.String;
	
	class MainClass
	{
		public static void Main(string[] args)
		{
			Console.WriteLine("Hello World!");
			String a="bonjour";
			int i=1;
			Console.WriteLine(i+a);
		}
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `int' to `System.IDisposable'
// Line: 8

class A
{
	public static void Main ()
	{
		System.IDisposable id = 1;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `A&lt;int&gt;.B&lt;long&gt;' to `A&lt;long&gt;.B&lt;long&gt;'
// Line: 14

class A&lt;T&gt;
{
	public class B&lt;U&gt;
	{
	}
}

class Test
{
	static A&lt;int&gt;.B&lt;long&gt; a;
	static A&lt;long&gt;.B&lt;long&gt; b = a;
}
</string>
    <string>// CS0029: Cannot implicitly convert type `int' to `(long, bool)'
// Line: 8

class C
{
	static void Test ()
	{
		System.ValueTuple&lt;long, bool&gt; arg = 1;
	}
}
</string>
    <string>// CS0019: Cannot implicitly convert type `dynamic' to `int*'
// Line: 10
// Compiler options: -unsafe

public unsafe class C
{
	public static void Main ()
	{
		dynamic d = 1;
		int* i = d;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `A.D' to `A'
// Line: 11

class A
{
	delegate void D ();

	public static void Main ()
	{
		const D d = null;
		A a = d;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `System.TypedReference' to `object'
// Line: 10

using System;

class Test
{
	public static void Main ()
	{
		var res = default (TypedReference).ToString ();
	}
}</string>
    <string>// CS0029: Cannot implicitly convert type `Bar&lt;long&gt;' to `Foo&lt;int&gt;'
// Line: 15
class Foo&lt;T&gt;
{
}

class Bar&lt;T&gt; : Foo&lt;T&gt;
{
}

class X
{
	static void Main ()
	{
		Foo&lt;int&gt; foo = new Bar&lt;long&gt; ();
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `T' to `int*'
// Line : 8
// Compiler options: -unsafe

class T {
	static unsafe void Main ()
	{
		int *a = (T) null;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `void' to `int'
// Line: 11

using System;
using System.Threading.Tasks;

class C
{
	public async Task&lt;int&gt; Test ()
	{
		return await Call ();
	}
	
	Task Call ()
	{
		return null;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `anonymous type' to `bool'
// Line: 10


public class Test
{
	static void Main ()
	{
		var o = new { Value = 1 };
		bool b = o;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `System.Runtime.InteropServices.CallingConvention'
// Line: 10

using System;
using System.Runtime.InteropServices;

namespace Tsunami {
  public sealed class Gl {

    [DllImport("libGL.so", EntryPoint="glCopyTexSubImage3D", CallingConvention="cdecl", ExactSpelling=true)]
    public static extern void CopyTexSubImage3D ();

  }
}

</string>
    <string>// CS0029: Cannot implicitly convert type `U' to `int'
// Line: 13

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

class B : A&lt;int&gt;
{
	public override void Foo&lt;U&gt; (U arg)
	{
		int i = arg;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `int' to `System.EventHandler'
// Line: 12

using System;

class C
{
	static event EventHandler h;
	
	public static void Main ()
	{
		h = 0;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `T' to `EventHandler'
// Line: 14

using System;

public delegate void EventHandler (int i, int j);

public class Button {

	public event EventHandler Click;

	public void Connect&lt;T&gt; () where T : class
	{
		Click += default (T);
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `MyTypeImplicitOnly?'
// Line: 13

struct MyTypeImplicitOnly
{
}

class C
{
	static void Main ()
	{
		MyTypeImplicitOnly? mt = null;
		mt = null + mt;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `int' to `A'
// Line: 14

class A
{
	public static implicit operator int (A x)
	{
		return 1;
	}
	
	public static void Main ()
	{
		var a = new A ();
		a++;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `int'
// Line: 10
// Compiler options: -unsafe

class TestClass
{
	public unsafe static void Main ()
	{
		int* arr = null;
		var i = arr["c"];
	}
}</string>
    <string>// CS0029: Cannot implicitly convert type `void' to `object'
// Line: 10

using System;

class TestClass
{
	public static void Main ()
	{
		Console.WriteLine ($"{ Main () }");		
	}
}</string>
    <string>// CS0029: Cannot implicitly convert type `int' to `string'
// Line: 5

class A {
	public static implicit operator string (A a)
	{ 
		return 42;
 	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `string' to `int'
// Line: 8

class A&lt;T&gt; where T : CB, IA
{
	void Foo (T t)
	{
		t.Prop = "3";
	}
}

class CB : CA
{
}

class CA
{
	public int Prop { get; set; }
}

interface IA
{
	string Prop { get; set; }
}</string>
    <string>// CS0029: Cannot implicitly convert type `T[]' to `U[]'
// Line: 8

class Test
{
	static void Main ()
	{
		Foo&lt;int, object&gt; (new int[] { 1 });
	}

	static U[] Foo&lt;T, U&gt; (T[] arg) where T : U where U : class
	{
		return arg;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `S' to `object'
// Line: 13
// Compiler options: -langversion:latest

public ref struct S
{
}

class Test
{
	public static void Main ()
	{
		object o = new S ();
	}
}</string>
    <string>// CS0029: Cannot implicitly convert type `void' to `System.EventHandler'
// Line: 14

class C
{
	static event System.EventHandler ev
	{
		add { }
		remove { }
	}

	static void Main ()
	{
		ev += ev += null;
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `char' to `char*'
// Line: 15
// Compiler options: -unsafe

unsafe struct MyStruct
{
	public fixed char Name[32];
}

unsafe class MainClass
{
	public static void Main ()
	{
		var str = new MyStruct ();
		str.Name = default (char);
	}
}
</string>
    <string>// CS0029: Cannot implicitly convert type `T' to `int*'
// Line : 8
// Compiler options: -unsafe

class T {
	static unsafe int Main ()
	{
		int *a = default(T);
	}
}
</string>
  </Examples>
</ErrorDocumentation>