<?xml version="1.0"?>
<ErrorDocumentation xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <ErrorName>CS0023</ErrorName>
  <Examples>
    <string>// CS0023: The `++' operator cannot be applied to operand of type `X'
// Line: 9

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

		x++;
	}
}
</string>
    <string>// CS0023: The `-' operator cannot be applied to operand of type `ulong'
// Line: 8

class X
{
	public static void Main ()
	{
		object o = -(9223372036854775808);
	}
}
</string>
    <string>// CS0023: The `.' operator cannot be applied to operand of type `int*'
// Line: 8
// Compiler options: -unsafe

class C
{
	static unsafe int* Foo ()
	{
		return (int*)0;
	}
	
	public static void Main ()
	{
		unsafe {
			string s = Foo().ToString ();
		}
	}
}</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `int'
// Line: 11

using System;

class C
{
	static void Main()
	{
		int k = 0;
		var r = k?.ToString ();
	}
}</string>
    <string>// CS0023: The `++' operator cannot be applied to operand of type `object'
// Line: 9

using System;
using System.Collections;

class Test {
	public static void Main(string[] args) {
		ArrayList al = new ArrayList();
		al[0] = 0;
		
		Console.WriteLine((al[0])++);
	}
}
</string>
    <string>// CS0023: The `.' operator cannot be applied to operand of type `method group'
// Line: 9

public class App {

  public static void Main() {}

  SomeEnum SomeEnum() {
    return SomeEnum.First;
  }

}

enum SomeEnum { First, Second };
</string>
    <string>// CS0023: The `is' operator cannot be applied to operand of type `default'
// Line: 9
// Compiler options: -langversion:latest

class C
{
	static void Main ()
	{
		bool d = default is C;
	}
}</string>
    <string>// CS0023: The `.' operator cannot be applied to operand of type `method group'
// Line: 20

using System;

enum Enum
{
	Test
}

class A : Attribute
{
	public A (object e)
	{
	}
}

class C
{
	[A (Enum.Test)]
	int Enum ()
	{
		return 0;
	}
}
</string>
    <string>// CS0023: The `.' operator cannot be applied to operand of type `void'
// Line: 12

using System; 
 
public class Testing 
{ 
	public static void DoNothing() {} 
	 
	public static void Main() 
	{ 
	 	Console.WriteLine(DoNothing().ToString()); 
	} 
} 
</string>
    <string>// CS0023: The `.' operator cannot be applied to operand of type `null'
// Line: 8

class C
{
	public static void Main ()
	{
		string s = null.ToString ();
	}
}</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `T'
// Line: 8

class X
{
	static void Bug&lt;T&gt;(System.Func&lt;T&gt; func)
	{
		var r = func?.Invoke ();
	}
}</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `null'
// Line: 8

class C
{
	static void Main ()
	{
		var res = null?[0];
	}
}</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `T'
// Line: 8

class C
{
	static void Foo&lt;T&gt; (T t) where T : struct
	{
		var r = t?.ToString ();
	}
}</string>
    <string>// CS0023: The `.' operator cannot be applied to operand of type `method group'
// Line: 14

using System;

public class Test
{
    public static void E () 
    { 
    }

    public static void Main () 
    {
        Console.WriteLine(E.x);
    }
}
</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `int*'
// Line: 10
// Compiler options: -unsafe

class C
{
	unsafe static void Main ()
	{
		int* arr = null;
		var v2 = arr?.ToString ();
	}
}</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `T'
// Line: 11

class C2&lt;T&gt;
{
	C2&lt;T&gt; i;
	T field;

	public void Foo ()
	{
		var x = i?.field;
	}
}</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `method group'
// Line: 14

class X
{
	void Test ()
	{
	}

	public static void Main ()
	{
		X x = null;
		System.Action n = x?.Test;
	}
}</string>
    <string>// CS0023: The `+' operator cannot be applied to operand of type `string'
// Line: 10

using System;

public class Test
{
	static void Main ()
	{
		Console.WriteLine ("a" + + "b");
	}
}</string>
    <string>// CS0023: The `+' operator cannot be applied to operand of type `X'
// Line : 6

class X {
    static X x;
    static object o = +x;
}
</string>
    <string>// CS0023: The `.' operator cannot be applied to operand of type `anonymous method'
// Line: 8

using System;
class Test {
	public static void Main(string[] argv) {
		Console.WriteLine("Type of anonymous block: {0}",
			(delegate() {}).GetType());
	}
}
</string>
    <string>// CS0023: The `++' operator cannot be applied to operand of type `bool'
// Line: 13

public class C{
  public static bool Foo{
    get{
      return false;
    }
    set{
    }	
  }
  public static void Main(){
    Foo++;
  }
}
</string>
    <string>// CS0023: The `~' operator cannot be applied to operand of type `Foo'
// Line : 10

public class Foo {

	public static void Main ()
	{
		Foo k = new Foo ();
		
		int i = ~ k;

	}
}
</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `void'
// Line: 10

using System;

class C
{
	static void Main ()
	{
		var v = Console.WriteLine ()?[0];
	}
}</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `T'
// Line: 13

interface IFoo&lt;T&gt;
{
	T Call ();
}

class C1
{
	U Foo&lt;T, U&gt; (IFoo&lt;T&gt; t)
	{
		return t?.Call ();
	}
}
</string>
    <string>// CS0023: The `?' operator cannot be applied to operand of type `int'
// Line: 9

public class C
{
	static void Main()
	{
		string s = null;
		var x = s?.Length?.ToString ();
	}
}</string>
    <string>// CS0023: The `+' operator cannot be applied to operand of type `X'
// Line : 6

class X {
        static void Foo (object o)
        {
        }
        
        static void Main () {
                Foo (+(X)null);
        }
}



</string>
    <string>// CS0023: The `!' operator cannot be applied to operand of type `int?'
// Line: 9

class Z
{
	public static void Main ()
	{
		int? n = null;
		var m = !n;
	}
}
</string>
    <string>// CS0023: The `-' operator cannot be applied to operand of type `ulong'
// Line : 6

class X {
    const ulong a = 2;
    const int b = -a;
}



</string>
    <string>// CS0023: The `+' operator cannot be applied to operand of type `bool'
// Line : 6

class X {
        static void Main () {
                bool b = +true;
        }
}



</string>
    <string>// CS0023: The `-' operator cannot be applied to operand of type `A'
// Line: 16


class A
{
	public static implicit operator ulong (A mask)
	{
		return 8;
	}
}

class X
{
    static A a = null;
    static object o = -a;
}
</string>
  </Examples>
</ErrorDocumentation>