Merge commit '2907aa04170e233faeb995aa99bd20eb77cd91d1'

Conflicts:
	mcs/mcs/anonymous.cs

Author: sushihangover

mcs/errors/cs0136-18.cs

@@ -0,0 +1,13 @@
+// CS0136: A local variable named `arg' cannot be declared in this scope because it would give a different meaning to `arg', which is already used in a `parent or current' scope to denote something else
+// Line: 11
+
+using System;
+
+class A (Func<int, int> barg)
+{
+}
+
+class B (int arg) 
+	: A ((arg) => 1)
+{
+}

mcs/errors/cs0136-19.cs

@@ -0,0 +1,13 @@
+// CS0136: A local variable named `arg' cannot be declared in this scope because it would give a different meaning to `arg', which is already used in a `parent or current' scope to denote something else
+// Line: 11
+
+using System;
+
+partial class PC
+{
+    Func<int, int> f = (arg) => 1;
+}
+
+partial class PC (int arg) 
+{
+}

mcs/mcs/anonymous.cs

@@ -1329,18 +1329,30 @@ protected virtual ParametersCompiled ResolveParameters (ResolveContext ec, TypeI
 			return Parameters;
 		}
 
-		protected override Expression DoResolve (ResolveContext ec)
+		protected override Expression DoResolve (ResolveContext rc)
 		{
-			var isPlayScript = ec.FileType == SourceFileType.PlayScript;
+			var isPlayScript = rc.FileType == SourceFileType.PlayScript;
 
-			if (ec.HasSet (ResolveContext.Options.ConstantScope)) {
-				ec.Report.Error (1706, loc, "Anonymous methods and lambda expressions cannot be used in the current context");
+			if (rc.HasSet (ResolveContext.Options.ConstantScope)) {
+				rc.Report.Error (1706, loc, "Anonymous methods and lambda expressions cannot be used in the current context");
 				return null;
 			}
 
 			//
-			// Set class type, set type
+			// Update top-level block generated duting parsing with actual top-level block
 			//
+			if (rc.HasAny (ResolveContext.Options.FieldInitializerScope | ResolveContext.Options.BaseInitializer) && rc.CurrentMemberDefinition.Parent.PartialContainer.PrimaryConstructorParameters != null) {
+				var tb = rc.ConstructorBlock.ParametersBlock.TopBlock;
+				if (Block.TopBlock != tb) {
+					Block b = Block;
+					while (b.Parent != Block.TopBlock && b != Block.TopBlock)
+						b = b.Parent;
+
+					b.Parent = tb;
+					tb.IncludeBlock (Block, Block.TopBlock);
+					b.ParametersBlock.TopBlock = tb;
+				}
+			}
 
 			eclass = ExprClass.Value;
 
@@ -1351,25 +1363,14 @@ protected override Expression DoResolve (ResolveContext ec)
 			// 
 			type = InternalType.AnonymousMethod;
 
-			if (!DoResolveParameters (ec))
+			if (!DoResolveParameters (rc))
 				return null;
 
-//<<<<<<< HEAD
-//#if !STATIC
-//			// FIXME: The emitted code isn't very careful about reachability
-//			// so, ensure we have a 'ret' at the end
-//			BlockContext bc = ec as BlockContext;
-//			if (bc != null && bc.CurrentBranching != null && bc.CurrentBranching.CurrentUsageVector.IsUnreachable)
-//				bc.NeedReturnLabel ();
-//#endif
-//
 			// Cast to Delgate for PlayScript (forces implicit conversion to Func<> or Action<> delegate types).
 			if (isPlayScript) {
-				return new Cast(new TypeExpression(ec.BuiltinTypes.Delegate, this.Location), this, this.Location).Resolve (ec);
+				return new Cast(new TypeExpression(rc.BuiltinTypes.Delegate, this.Location), this, this.Location).Resolve (rc);
 			}
 
-//=======
-//>>>>>>> d12330eda7746321b4611865d11e932e53ac55b8
 			return this;
 		}
 

mcs/mcs/class.cs

@@ -1823,8 +1823,12 @@ bool DoDefineBaseType ()
 			// defined after current container
 			//
 			if (class_partial_parts != null) {
-				foreach (var pp in class_partial_parts)
+				foreach (var pp in class_partial_parts) {
+					if (pp.PrimaryConstructorBaseArguments != null)
+						PrimaryConstructorBaseArguments = pp.PrimaryConstructorBaseArguments;
+
 					pp.DoDefineBaseType ();
+				}
 
 			}
 
@@ -2915,7 +2919,7 @@ protected virtual Constructor DefineDefaultConstructor (bool is_static)
 
 			AddConstructor (c, true);
 			if (PrimaryConstructorBlock == null) {
-				c.Block = new ToplevelBlock (Compiler, c.ParameterInfo, Location) {
+				c.Block = new ToplevelBlock (Compiler, parameters, Location) {
 					IsCompilerGenerated = true
 				};
 			} else {

mcs/mcs/expression.cs

@@ -12372,8 +12372,10 @@ public override void EmitStatement (EmitContext ec)
 
 		public override void FlowAnalysis (FlowAnalysisContext fc)
 		{
-			foreach (var initializer in initializers)
-				initializer.FlowAnalysis (fc);
+			foreach (var initializer in initializers) {
+				if (initializer != null)
+					initializer.FlowAnalysis (fc);
+			}
 		}
 	}
 

mcs/mcs/statement.cs

@@ -4021,6 +4021,9 @@ public ToplevelBlock TopBlock {
 			get {
 				return top_block;
 			}
+			set {
+				top_block = value;
+			}
 		}
 
 		public bool Resolved {
@@ -4799,6 +4802,24 @@ public bool GetLocalName (string name, Block block, ref INamedBlockVariable vari
 			return false;
 		}
 
+		public void IncludeBlock (ParametersBlock pb, ToplevelBlock block)
+		{
+			if (block.names != null) {
+				foreach (var n in block.names) {
+					var variable = n.Value as INamedBlockVariable;
+					if (variable != null) {
+						if (variable.Block.ParametersBlock == pb)
+							AddLocalName (n.Key, variable, false);
+						continue;
+					}
+
+					foreach (var v in (List<INamedBlockVariable>) n.Value)
+						if (v.Block.ParametersBlock == pb)
+							AddLocalName (n.Key, v, false);
+				}
+			}
+		}
+
 		// <summary>
 		//   This is used by non-static `struct' constructors which do not have an
 		//   initializer - in this case, the constructor must initialize all of the

mcs/tests/gtest-collectioninit-04.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+
+class X
+{
+    internal static Dictionary<Type, Func<string, string>> Test = new Dictionary<Type, Func<string, string>> { {
+            typeof (int),
+            metadata => "1"
+        }, {
+            typeof (uint),
+            metadata => "2"
+        },
+    };
+
+    public static void Main ()
+    {
+    }
+}

mcs/tests/test-primary-ctor-09.cs

@@ -0,0 +1,30 @@
+using System;
+
+class A (Func<int, int> barg)
+{
+	public Func<int, int> BaseArg = barg;
+}
+
+partial class PC
+{
+	public Func<int, int> f1 = (a) => arg;
+}
+
+partial class PC (int arg) 
+	: A ((a) => arg)
+{
+}
+
+class X
+{
+	public static int Main ()
+	{
+		if (new PC (3).f1 (4) != 3)
+			return 1;
+
+		if (new PC (3).BaseArg (4) != 3)
+			return 2;
+
+		return 0;
+	}
+}