<?xml version="1.0" encoding="us-ascii"?>
<ErrorDocumentation xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <ErrorName>CS0122</ErrorName>
  <Examples>
    <string>// cs0122: `X.Y.Y(string)' is inaccessible due to its protection level
// Line: 9
// Compiler options: -r:CS0122-10-lib.dll

using System;
using X;

class T : Y {
	public T(String test, String test1) : base(test) {
	}
	static void Main () {}
}
</string>
    <string>// cs0122-11.cs: `Y.Y(string)' is inaccessible due to its protection level
// Line: 12

using System;

public class Y {
	private Y(String test) {
	}
}

class T : Y {
	public T(String test, String test1) : base(test) {
	}
	static void Main () {}
}
</string>
    <string>// CS0122: `Test.SomeAttribute.SomeAttribute()' is inaccessible due to its protection level
// Line: 10

using System;

namespace Test
{
	public class SomeAttribute : Attribute
	{
		SomeAttribute() {}
	}

	[SomeAttribute]
	public class SomeClass
	{
	} 
}
</string>
    <string>// cs0122-13.cs: `Test.foo' is inaccessible due to its protection level
// Line: 10

internal class Test 
{
	protected const int foo = 0;
}
internal class Rest
{
	protected const int foo = Test.foo;

	static void Main () {}
}
</string>
    <string>// cs0122-14.cs: `Test.SomeValue' is inaccessible due to its protection level
// Line: 7
// Compiler options: -r:CS0122-14-lib.dll

public class MyEnum
{
	int Unknown = Test.SomeValue;
	static void Main () {}
}

</string>
    <string>// cs0122-15.cs: `Test.SomeValue' is inaccessible due to its protection level
// Line: 7
// Compiler options: -r:CS0122-15-lib.dll

public class MyEnum
{
	int Unknown = Test.SomeValue;
	static void Main () {}
}

</string>
    <string>// cs0122-16.cs: `A.x' is inaccessible due to its protection level
// Line: 16

public class A
{
	protected bool x = true;
	
	public A()
	{}
}

public class B
{
	public static void Main(string[] args)
	{
		if (new A().x)
		{
			System.Console.WriteLine("this should not compile");
		}
	}
}
</string>
    <string>// cs0122-17.cs: `A.output' is inaccessible due to its protection level
// Line: 12

public class A {
        private string output;
}

public class B : A {
        public void Test() {
                switch ("a") {
                        case "1":
                                output.Replace("a", "b");
                                break;
                }
        }
}
</string>
    <string>// cs0122-18.cs: `Test.TestClass.TestClass()' is inaccessible due to its protection level
// Line: 17

namespace Test
{
	public class TestClass
	{
		private TestClass() : base()
		{
		}
	}

	class Class1
	{
		static void Main(string[] args)
		{
			TestClass test = new TestClass();
		}
	}
} </string>
    <string>// cs0122-19.cs: `A.IFileWatcher' is inaccessible due to its protection level
// Line: 9
// Compiler options: -r:CS0122-19-lib.dll

namespace A {
	class C {
		public static void Main ()
		{
			IFileWatcher i;
		}
	}
}</string>
    <string>// cs0122-2.cs: `A.prop' is inaccessible due to its protection level
// Line: 19
// Compiler options: -t:library

class A
{
        int i;

        int prop
        {
                set { i = value; }
        }
}

class B : A
{
        void M ()
        {
                prop = 2;
        }
}
</string>
    <string>// cs0122-20.cs: `A.B' is inaccessible due to its protection level
// Line: 4

using C = A.B;

class A
{
	class B {}
}</string>
    <string>// cs0122-21.cs: `Const.Version' is inaccessible due to its protection level
// Line: 6

using System.Reflection;

[assembly: AssemblyVersion(Const.Version)]

class Const
{
	const string Version = "0.1";
}
</string>
    <string>// CS0122: `Test.A.B' is inaccessible due to its protection level
// Line: 6

namespace Test
{
	public sealed class A
	{
		private class B
		{
			public static void Method ()
			{
			}
		}
	}
	
	class MainClass
	{
		public static void Main(string[] args)
		{
			A.B.Method ();
		}
	}
}
</string>
    <string>// CS0122: `C.this[int]' is inaccessible due to its protection level
// Line: 6

using System;
using System.Collections;

class C
{
	protected string this [int i] { set {} }
}

public class D
{
	void Foo ()
	{
		C c = new C ();
		c [0] = null;
	}
}
</string>
    <string>// CS0122: `Foo.this[int]' is inaccessible due to its protection level
// Line: 14

using System;
	
public class Foo {
	private int this[int index] { get { return index; } }
}
	
public class Bar {
	public static void Main ()
	{
		Foo foo = new Foo ();
		Console.WriteLine (foo[5]);
	}
}
</string>
    <string>// CS0122: `AAttribute.AAttribute()' is inaccessible due to its protection level
// Line: 9

class AAttribute : System.Attribute
{
	protected AAttribute() { }
}

[A]
class C
{
}
</string>
    <string>// CS0122: `C.I' is inaccessible due to its protection level
// Line: 11

class C
{
	protected interface I
	{
	}
}

class A : C.I
{
}
</string>
    <string>// CS0122: `G.GG' is inaccessible due to its protection level
// Line: 14

class G
{
	private class GG
	{
		public class F { }
	}
}

class X
{
	G.GG.F foo;
}

</string>
    <string>// CS0122: `A.X' is inaccessible due to its protection level
// Line: 18

using System;

class A
{
	class X
	{
		public static string V = "a";
	}
}

class C : A
{
	public static void Main ()
	{
		Console.WriteLine (X.V);
	}
}
</string>
    <string>// CS0122: `Foo.Bar()' is inaccessible due to its protection level
// Line: 17

using System;

public class Foo
{
	void Bar ()
	{
	}
}

public class Baz : Foo
{
	public static void Main (String[] args)
	{
		Bar ();
	}
}
</string>
    <string>// cs0122-3.cs: `A.B' is inaccessible due to its protection level
// Line: 11

interface r {
	A.B aaa ();
}

class A {
	enum B {
		D
	}
}

class B {
	static void Main ()
	{
		A.B x = A.B.D;
	}
}
</string>
    <string>// CS0122: `MainClass.Nested.Delegate()' is inaccessible due to its protection level
// Line: 18

delegate int TestDelegate ();

public class MainClass
{
	class Nested
	{
		static int Delegate ()
		{
			return 0;
		}
	}

	public static void Main ()
	{
		TestDelegate delegateInstance = new TestDelegate (Nested.Delegate);
	}
}

</string>
    <string>// CS0122: `Data.Count' is inaccessible due to its protection level
// Line: 13

class Data
{
	int Count;
}

public class Test
{
	static void Main ()
	{
		var c = new Data { Count = 10 };
	}
}
</string>
    <string>// CS0122: `A.Foo()' is inaccessible due to its protection level
// Line: 23

class A
{
	public void Foo (int i)
	{
	}

	private void Foo ()
	{
	}
}

class B : A
{
	public static void Main ()
	{
	}

	void Test ()
	{
		Foo ();
	}
}</string>
    <string>// CS0122: `M.Test&lt;S.P&gt;(I&lt;S.P&gt;)' is inaccessible due to its protection level
// Line: 27

interface I&lt;T&gt;
{
}

struct S
{
	class P
	{
	}
	
	public class C : I&lt;P&gt;
	{
	}
}

class M
{
	static void Test&lt;T&gt;(I&lt;T&gt; iface)
	{
	}

	static void Test()
	{
		Test (new S.C ());
	}
}
</string>
    <string>// cs0122-4.cs: `FooAttribute.Foo' is inaccessible due to its protection level
// Line: 11
// This is bug #55970

using System;

public sealed class FooAttribute : Attribute {
	int Foo;
}

[Foo (Foo = 1)]
public class Tests {
	public static void Main () {
	}
}</string>
    <string>// cs0122-5.cs: `Test.Foo.Bar' is inaccessible due to its protection level
// Line: 11

public class Test
{
	public class Foo
	{
		private class Bar {}
	}
	
	private class Bar : Foo.Bar
	{
	}

	public static void Main () {}
}

</string>
    <string>// cs0122-6.cs: `Test.Foo.IBar' is inaccessible due to its protection level
// Line: 11

public class Test
{
	public class Foo
	{
		protected interface IBar {}
	}
	
	private class Bar : Foo.IBar
	{
	}

	public static void Main () {}
}

</string>
    <string>// cs0122-7.cs: `BB.AnEvent' is inaccessible due to its protection level
// Line: 10

using System;

class X 
{
       static void Main ()
       {
               BB b = new BB ();
               b.AnEvent += DoIt;
       }
       
       public static void DoIt (object sender, EventArgs args) {}
}

public class BB
{
       event EventHandler AnEvent;
}

</string>
    <string>// cs0122-8.cs: `A.member' is inaccessible due to its protection level
// Line: 17
// NOTE: if `member' were a field or a property, this'd be CS1540

using System;

class A
{
       protected event EventHandler member;
}

class B : A
{
       static void Main ()
       {
               A a = new A ();
               a.member += Handler;
       }
       
       static void Handler (object sender, EventArgs args) {}
}


</string>
    <string>// CS0122: `X.a' is inaccessible due to its protection level
// Line: 16

public class X {
	private int a {
		get {
			return 1;
		}
	}
}

internal class Y : X
{
	int D (X x)
	{
		if (x.a == 2)
			return 0;
		return 0;
	}
}
</string>
    <string>// cs0122.cs: `Y.x()' is inaccessible due to its protection level
// Line: 15
using System;

class Y {
	void x () {}

}

class X {
	static int Main ()
	{
		Y y = new Y ();

		y.x ();
		return 0;
	}
}
</string>
  </Examples>
</ErrorDocumentation>