Updated mcs.

ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs

@@ -2387,7 +2387,9 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				if (binaryExpression.Left != null)
 					result.AddChild ((Expression)binaryExpression.Left.Accept (this), BinaryOperatorExpression.LeftRole);
-				result.AddChild (new CSharpTokenNode (Convert (binaryExpression.Location)), BinaryOperatorExpression.GetOperatorRole (result.Operator));
+				var location = LocationsBag.GetLocations (binaryExpression);
+				if (location != null)
+					result.AddChild (new CSharpTokenNode (Convert (location[0])), BinaryOperatorExpression.GetOperatorRole (result.Operator));
 				if (binaryExpression.Right != null)
 					result.AddChild ((Expression)binaryExpression.Right.Accept (this), BinaryOperatorExpression.RightRole);
 				return result;
@@ -2399,7 +2401,9 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.Operator = BinaryOperatorType.NullCoalescing;
 				if (nullCoalescingOperator.LeftExpression != null)
 					result.AddChild ((Expression)nullCoalescingOperator.LeftExpression.Accept (this), BinaryOperatorExpression.LeftRole);
-				result.AddChild (new CSharpTokenNode (Convert (nullCoalescingOperator.Location)), BinaryOperatorExpression.NullCoalescingRole);
+				var location = LocationsBag.GetLocations (nullCoalescingOperator);
+				if (location != null)
+					result.AddChild (new CSharpTokenNode (Convert (location[0])), BinaryOperatorExpression.NullCoalescingRole);
 				if (nullCoalescingOperator.RightExpression != null)
 					result.AddChild ((Expression)nullCoalescingOperator.RightExpression.Accept (this), BinaryOperatorExpression.RightRole);
 				return result;
@@ -3073,7 +3077,9 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.Operator = AssignmentOperatorType.Assign;
 				if (simpleAssign.Target != null)
 					result.AddChild ((Expression)simpleAssign.Target.Accept (this), AssignmentExpression.LeftRole);
-				result.AddChild (new CSharpTokenNode (Convert (simpleAssign.Location)), AssignmentExpression.AssignRole);
+				var location = LocationsBag.GetLocations (simpleAssign);
+				if (location != null)
+					result.AddChild (new CSharpTokenNode (Convert (location[0])), AssignmentExpression.AssignRole);
 				if (simpleAssign.Source != null) {
 					result.AddChild ((Expression)simpleAssign.Source.Accept (this), AssignmentExpression.RightRole);
 				}
@@ -3118,7 +3124,9 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				if (compoundAssign.Target != null)
 					result.AddChild ((Expression)compoundAssign.Target.Accept (this), AssignmentExpression.LeftRole);
-				result.AddChild (new CSharpTokenNode (Convert (compoundAssign.Location)), AssignmentExpression.GetOperatorRole (result.Operator));
+				var location = LocationsBag.GetLocations (compoundAssign);
+				if (location != null)
+					result.AddChild (new CSharpTokenNode (Convert (location[0])), AssignmentExpression.GetOperatorRole (result.Operator));
 				if (compoundAssign.Source != null)
 					result.AddChild ((Expression)compoundAssign.Source.Accept (this), AssignmentExpression.RightRole);
 				return result;
@@ -3778,11 +3786,13 @@ namespace ICSharpCode.NRefactory.CSharp
 				var file = new SourceFile (fileName, fileName, 0);
 				Location.Initialize (new List<SourceFile> (new [] { file }));
 				var module = new ModuleContainer (ctx);
-				var parser = Driver.Parse (reader, file, module, lineModifier);
-
+				var session = new ParserSession ();
+				session.LocationsBag = new LocationsBag ();
+				var report = new Report (ctx, errorReportPrinter);
+				var parser = Driver.Parse (reader, file, module, session, report, lineModifier);
 				var top = new CompilerCompilationUnit () {
 					ModuleCompiled = module,
-					LocationsBag = parser.LocationsBag,
+					LocationsBag = session.LocationsBag,
 					SpecialsBag = parser.Lexer.sbag,
 					Conditionals = parser.Lexer.SourceFile.Conditionals
 				};
@@ -3879,10 +3889,12 @@ namespace ICSharpCode.NRefactory.CSharp
 				var file = new SourceFile("", "", 0);
 				Location.Initialize(new List<SourceFile> (new [] { file }));
 				var module = new ModuleContainer(ctx);
-				module.DocumentationBuilder = new DocumentationBuilder();
+				module.DocumentationBuilder = new DocumentationBuilder(module);
 				var source_file = new CompilationSourceFile (module);
 				var report = new Report (ctx, errorReportPrinter);
-				var parser = new Mono.CSharp.CSharpParser (reader, source_file, report);
+				ParserSession session = new ParserSession ();
+				session.LocationsBag = new LocationsBag ();
+				var parser = new Mono.CSharp.CSharpParser (reader, source_file, report, session);
 				parser.Lexer.putback_char = Tokenizer.DocumentationXref;
 				parser.Lexer.parsing_generic_declaration_doc = true;
 				parser.parse ();
@@ -3891,7 +3903,7 @@ namespace ICSharpCode.NRefactory.CSharp
 //					                mc.GetSignatureForError (), cref);
 				}
 				
-				ConversionVisitor conversionVisitor = new ConversionVisitor (false, parser.LocationsBag);
+				ConversionVisitor conversionVisitor = new ConversionVisitor (false, session.LocationsBag);
 				DocumentationReference docRef = conversionVisitor.ConvertXmlDoc(module.DocumentationBuilder);
 				CompilerCallableEntryPoint.Reset();
 				return docRef;

ICSharpCode.NRefactory.CSharp/Parser/mcs/MonoSymbolFile.cs

@@ -53,7 +53,7 @@ namespace Mono.CompilerServices.SymbolWriter
 		}
 	}
 
-	internal class MyBinaryWriter : BinaryWriter
+	sealed class MyBinaryWriter : BinaryWriter
 	{
 		public MyBinaryWriter (Stream stream)
 			: base (stream)

ICSharpCode.NRefactory.CSharp/Parser/mcs/MonoSymbolTable.cs

@@ -183,6 +183,7 @@ namespace Mono.CompilerServices.SymbolWriter
 	{
 		#region This is actually written to the symbol file
 		public readonly int Row;
+		public int Column;
 		public readonly int File;
 		public readonly int Offset;
 		public readonly bool IsHidden;	// Obsolete is never used
@@ -195,28 +196,35 @@ namespace Mono.CompilerServices.SymbolWriter
 			public int Compare (LineNumberEntry l1, LineNumberEntry l2)
 			{
 				return l1.Row == l2.Row ?
-					l1.Offset.CompareTo (l2.Offset) :
+					l1.Column.CompareTo (l2.Column) :
 					l1.Row.CompareTo (l2.Row);
 			}
 		}
 
-		public static readonly LineNumberEntry Null = new LineNumberEntry (0, 0, 0);
+		public static readonly LineNumberEntry Null = new LineNumberEntry (0, 0, 0, 0);
+
+		public LineNumberEntry (int file, int row, int column, int offset)
+			: this (file, row, offset, column, false)
+		{
+		}
 
 		public LineNumberEntry (int file, int row, int offset)
-			: this (file, row, offset, false)
-		{ }
+			: this (file, row, -1, offset, false)
+		{
+		}
 
-		public LineNumberEntry (int file, int row, int offset, bool is_hidden)
+		public LineNumberEntry (int file, int row, int column, int offset, bool is_hidden)
 		{
 			this.File = file;
 			this.Row = row;
+			this.Column = column;
 			this.Offset = offset;
 			this.IsHidden = is_hidden;
 		}
 
 		public override string ToString ()
 		{
-			return String.Format ("[Line {0}:{1}:{2}]", File, Row, Offset);
+			return String.Format ("[Line {0}:{1,2}:{3}]", File, Row, Column, Offset);
 		}
 	}
 
@@ -675,8 +683,7 @@ namespace Mono.CompilerServices.SymbolWriter
 			creating = true;
 		}
 
-		public SourceFileEntry (MonoSymbolFile file, string file_name,
-					byte[] guid, byte[] checksum)
+		public SourceFileEntry (MonoSymbolFile file, string file_name, byte[] guid, byte[] checksum)
 			: this (file, file_name)
 		{
 			this.guid = guid;
@@ -694,13 +701,15 @@ namespace Mono.CompilerServices.SymbolWriter
 			DataOffset = (int) bw.BaseStream.Position;
 			bw.Write (file_name);
 
-			if (guid == null) {
-				guid = Guid.NewGuid ().ToByteArray ();
+			if (guid == null)
+				guid = new byte[16];
+
+			if (hash == null) {
 				try {
-					using (FileStream fs = new FileStream (file_name, FileMode.Open, FileAccess.Read)) {
-						MD5 md5 = MD5.Create ();
-						hash = md5.ComputeHash (fs);
-					}
+				    using (FileStream fs = new FileStream (file_name, FileMode.Open, FileAccess.Read)) {
+				        MD5 md5 = MD5.Create ();
+				        hash = md5.ComputeHash (fs);
+				    }
 				} catch {
 					hash = new byte [16];
 				}
@@ -791,7 +800,6 @@ namespace Mono.CompilerServices.SymbolWriter
 		public const int Default_LineRange = 8;
 		public const byte Default_OpcodeBase = 9;
 
-		public const bool SuppressDuplicates = true;
 #endregion
 
 		public const byte DW_LNS_copy = 1;
@@ -822,7 +830,7 @@ namespace Mono.CompilerServices.SymbolWriter
 			this._line_numbers = lines;
 		}
 
-		internal void Write (MonoSymbolFile file, MyBinaryWriter bw)
+		internal void Write (MonoSymbolFile file, MyBinaryWriter bw, bool readColumnsInfo)
 		{
 			int start = (int) bw.BaseStream.Position;
 
@@ -832,11 +840,6 @@ namespace Mono.CompilerServices.SymbolWriter
 				int line_inc = LineNumbers [i].Row - last_line;
 				int offset_inc = LineNumbers [i].Offset - last_offset;
 
-				if (SuppressDuplicates && (i+1 < LineNumbers.Length)) {
-					if (LineNumbers [i+1].Equals (LineNumbers [i]))
-						continue;
-				}
-
 				if (LineNumbers [i].File != last_file) {
 					bw.Write (DW_LNS_set_file);
 					bw.WriteLeb128 (LineNumbers [i].File);
@@ -884,17 +887,23 @@ namespace Mono.CompilerServices.SymbolWriter
 			bw.Write ((byte) 1);
 			bw.Write (DW_LNE_end_sequence);
 
+			for (int i = 0; i < LineNumbers.Length; i++) {
+				var ln = LineNumbers [i];
+				if (ln.Row >= 0)
+					bw.WriteLeb128 (ln.Column);
+			}
+
 			file.ExtendedLineNumberSize += (int) bw.BaseStream.Position - start;
 		}
 
-		internal static LineNumberTable Read (MonoSymbolFile file, MyBinaryReader br)
+		internal static LineNumberTable Read (MonoSymbolFile file, MyBinaryReader br, bool readColumnsInfo)
 		{
 			LineNumberTable lnt = new LineNumberTable (file);
-			lnt.DoRead (file, br);
+			lnt.DoRead (file, br, readColumnsInfo);
 			return lnt;
 		}
 
-		void DoRead (MonoSymbolFile file, MyBinaryReader br)
+		void DoRead (MonoSymbolFile file, MyBinaryReader br, bool includesColumns)
 		{
 			var lines = new List<LineNumberEntry> ();
 
@@ -911,7 +920,7 @@ namespace Mono.CompilerServices.SymbolWriter
 					if (opcode == DW_LNE_end_sequence) {
 						if (modified)
 							lines.Add (new LineNumberEntry (
-								stm_file, stm_line, stm_offset, is_hidden));
+								stm_file, stm_line, -1, stm_offset, is_hidden));
 						break;
 					} else if (opcode == DW_LNE_MONO_negate_is_hidden) {
 						is_hidden = !is_hidden;
@@ -929,7 +938,7 @@ namespace Mono.CompilerServices.SymbolWriter
 					switch (opcode) {
 					case DW_LNS_copy:
 						lines.Add (new LineNumberEntry (
-							stm_file, stm_line, stm_offset, is_hidden));
+							stm_file, stm_line, -1, stm_offset, is_hidden));
 						modified = false;
 						break;
 					case DW_LNS_advance_pc:
@@ -959,13 +968,20 @@ namespace Mono.CompilerServices.SymbolWriter
 					stm_offset += opcode / LineRange;
 					stm_line += LineBase + (opcode % LineRange);
 					lines.Add (new LineNumberEntry (
-						stm_file, stm_line, stm_offset, is_hidden));
+						stm_file, stm_line, -1, stm_offset, is_hidden));
 					modified = false;
 				}
 			}
 
-			_line_numbers = new LineNumberEntry [lines.Count];
-			lines.CopyTo (_line_numbers, 0);
+			_line_numbers = lines.ToArray ();
+
+			if (includesColumns) {
+				for (int i = 0; i < _line_numbers.Length; ++i) {
+					var ln = _line_numbers[i];
+					if (ln.Row >= 0)
+						ln.Column = br.ReadLeb128 ();
+				}
+			}
 		}
 
 		public bool GetMethodBounds (out LineNumberEntry start, out LineNumberEntry end)
@@ -1022,7 +1038,8 @@ namespace Mono.CompilerServices.SymbolWriter
 		[Flags]
 		public enum Flags
 		{
-			LocalNamesAmbiguous	= 1
+			LocalNamesAmbiguous	= 1,
+			ColumnsInfoIncluded = 1 << 1
 		}
 
 		public const int Size = 12;
@@ -1176,7 +1193,7 @@ namespace Mono.CompilerServices.SymbolWriter
 			}
 
 			LineNumberTableOffset = (int) bw.BaseStream.Position;
-			lnt.Write (file, bw);
+			lnt.Write (file, bw, (flags & Flags.ColumnsInfoIncluded) != 0);
 
 			DataOffset = (int) bw.BaseStream.Position;
 
@@ -1204,7 +1221,7 @@ namespace Mono.CompilerServices.SymbolWriter
 				long old_pos = reader.BaseStream.Position;
 				reader.BaseStream.Position = LineNumberTableOffset;
 
-				lnt = LineNumberTable.Read (SymbolFile, reader);
+				lnt = LineNumberTable.Read (SymbolFile, reader, (flags & Flags.ColumnsInfoIncluded) != 0);
 
 				reader.BaseStream.Position = old_pos;
 				return lnt;

ICSharpCode.NRefactory.CSharp/Parser/mcs/SourceMethodBuilder.cs

@@ -64,7 +64,7 @@ namespace Mono.CompilerServices.SymbolWriter
 		public void MarkSequencePoint (int offset, SourceFileEntry file, int line, int column, bool is_hidden)
 		{
 			int file_idx = file != null ? file.Index : 0;
-			var lne = new LineNumberEntry (file_idx, line, offset, is_hidden);
+			var lne = new LineNumberEntry (file_idx, line, column, offset, is_hidden);
 
 			if (method_lines.Count > 0) {
 				var prev = method_lines[method_lines.Count - 1];
@@ -185,7 +185,7 @@ namespace Mono.CompilerServices.SymbolWriter
 		{
 			MethodEntry entry = new MethodEntry (
 				file, _comp_unit.Entry, token, ScopeVariables,
-				Locals, method_lines.ToArray (), Blocks, null, 0, ns_id);
+				Locals, method_lines.ToArray (), Blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id);
 
 			file.AddMethod (entry);
 		}

ICSharpCode.NRefactory.CSharp/Parser/mcs/anonymous.cs

@@ -816,7 +816,7 @@ namespace Mono.CSharp {
 		sealed class HoistedFieldAssign : CompilerAssign
 		{
 			public HoistedFieldAssign (Expression target, Expression source)
-				: base (target, source, source.Location)
+				: base (target, source, target.Location)
 			{
 			}
 
@@ -1503,6 +1503,10 @@ namespace Mono.CSharp {
 
 			aec.Set (flags);
 
+			var bc = ec as BlockContext;
+			if (bc != null)
+				aec.FlowOffset = bc.FlowOffset;
+
 			var errors = ec.Report.Errors;
 
 			bool res = Block.Resolve (ec.CurrentBranching, aec, null);
@@ -2013,11 +2017,11 @@ namespace Mono.CSharp {
 
 				IntConstant FNV_prime = new IntConstant (Compiler.BuiltinTypes, 16777619, loc);				
 				rs_hashcode = new Binary (Binary.Operator.Multiply,
-					new Binary (Binary.Operator.ExclusiveOr, rs_hashcode, field_hashcode, loc),
-					FNV_prime, loc);
+					new Binary (Binary.Operator.ExclusiveOr, rs_hashcode, field_hashcode),
+					FNV_prime);
 
 				Expression field_to_string = new Conditional (new BooleanExpression (new Binary (Binary.Operator.Inequality,
-					new MemberAccess (new This (f.Location), f.Name), new NullLiteral (loc), loc)),
+					new MemberAccess (new This (f.Location), f.Name), new NullLiteral (loc))),
 					new Invocation (new MemberAccess (
 						new MemberAccess (new This (f.Location), f.Name), "ToString"), null),
 					new StringConstant (Compiler.BuiltinTypes, string.Empty, loc), loc);
@@ -2028,9 +2032,7 @@ namespace Mono.CSharp {
 						string_concat,
 						new Binary (Binary.Operator.Addition,
 							new StringConstant (Compiler.BuiltinTypes, " " + p.Name + " = ", loc),
-							field_to_string,
-							loc),
-						loc);
+							field_to_string));
 					continue;
 				}
 
@@ -2040,18 +2042,15 @@ namespace Mono.CSharp {
 				string_concat = new Binary (Binary.Operator.Addition,
 					new Binary (Binary.Operator.Addition,
 						string_concat,
-						new StringConstant (Compiler.BuiltinTypes, ", " + p.Name + " = ", loc),
-						loc),
-					field_to_string,
-					loc);
+						new StringConstant (Compiler.BuiltinTypes, ", " + p.Name + " = ", loc)),
+					field_to_string);
 
-				rs_equals = new Binary (Binary.Operator.LogicalAnd, rs_equals, field_equal, loc);
+				rs_equals = new Binary (Binary.Operator.LogicalAnd, rs_equals, field_equal);
 			}
 
 			string_concat = new Binary (Binary.Operator.Addition,
 				string_concat,
-				new StringConstant (Compiler.BuiltinTypes, " }", loc),
-				loc);
+				new StringConstant (Compiler.BuiltinTypes, " }", loc));
 
 			//
 			// Equals (object obj) override
@@ -2062,9 +2061,9 @@ namespace Mono.CSharp {
 					new As (equals_block.GetParameterReference (0, loc),
 						current_type, loc), loc)));
 
-			Expression equals_test = new Binary (Binary.Operator.Inequality, other_variable, new NullLiteral (loc), loc);
+			Expression equals_test = new Binary (Binary.Operator.Inequality, other_variable, new NullLiteral (loc));
 			if (rs_equals != null)
-				equals_test = new Binary (Binary.Operator.LogicalAnd, equals_test, rs_equals, loc);
+				equals_test = new Binary (Binary.Operator.LogicalAnd, equals_test, rs_equals);
 			equals_block.AddStatement (new Return (equals_test, loc));
 
 			equals.Block = equals_block;
@@ -2106,19 +2105,19 @@ namespace Mono.CSharp {
 			var hash_variable = new LocalVariableReference (li_hash, loc);
 			hashcode_block.AddStatement (new StatementExpression (
 				new CompoundAssign (Binary.Operator.Addition, hash_variable,
-					new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 13, loc), loc), loc)));
+					new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 13, loc)))));
 			hashcode_block.AddStatement (new StatementExpression (
 				new CompoundAssign (Binary.Operator.ExclusiveOr, hash_variable,
-					new Binary (Binary.Operator.RightShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 7, loc), loc), loc)));
+					new Binary (Binary.Operator.RightShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 7, loc)))));
 			hashcode_block.AddStatement (new StatementExpression (
 				new CompoundAssign (Binary.Operator.Addition, hash_variable,
-					new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 3, loc), loc), loc)));
+					new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 3, loc)))));
 			hashcode_block.AddStatement (new StatementExpression (
 				new CompoundAssign (Binary.Operator.ExclusiveOr, hash_variable,
-					new Binary (Binary.Operator.RightShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 17, loc), loc), loc)));
+					new Binary (Binary.Operator.RightShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 17, loc)))));
 			hashcode_block.AddStatement (new StatementExpression (
 				new CompoundAssign (Binary.Operator.Addition, hash_variable,
-					new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 5, loc), loc), loc)));
+					new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 5, loc)))));
 
 			hashcode_block.AddStatement (new Return (hash_variable, loc));
 			hashcode.Block = hashcode_top;

ICSharpCode.NRefactory.CSharp/Parser/mcs/argument.cs

@@ -320,20 +320,20 @@ namespace Mono.CSharp
 
 				if (a.Expr is Constant) {
 					info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
-						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "Constant", loc), loc);
+						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "Constant", loc));
 				} else if (a.ArgType == Argument.AType.Ref) {
 					info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
-						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsRef", loc), loc);
+						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsRef", loc));
 					info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
-						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc), loc);
+						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
 				} else if (a.ArgType == Argument.AType.Out) {
 					info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
-						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsOut", loc), loc);
+						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsOut", loc));
 					info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
-						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc), loc);
+						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
 				} else if (a.ArgType == Argument.AType.DynamicTypeName) {
 					info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
-						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsStaticType", loc), loc);
+						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsStaticType", loc));
 				}
 
 				var arg_type = a.Expr.Type;
@@ -354,14 +354,14 @@ namespace Mono.CSharp
 					}
 
 					info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
-						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc), loc);
+						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
 				}
 
 				string named_value;
 				NamedArgument na = a as NamedArgument;
 				if (na != null) {
 					info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
-						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "NamedArgument", loc), loc);
+						new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "NamedArgument", loc));
 
 					named_value = na.Name;
 				} else {

ICSharpCode.NRefactory.CSharp/Parser/mcs/assign.cs

@@ -543,11 +543,11 @@ namespace Mono.CSharp {
 		ExpressionStatement resolved;
 		IMemberContext mc;
 
-		public FieldInitializer (FieldSpec spec, Expression expression, IMemberContext mc)
-			: base (new FieldExpr (spec, expression.Location), expression, expression.Location)
+		public FieldInitializer (FieldBase mc, Expression expression, Location loc)
+			: base (new FieldExpr (mc.Spec, expression.Location), expression, loc)
 		{
 			this.mc = mc;
-			if (!spec.IsStatic)
+			if (!mc.IsStatic)
 				((FieldExpr)target).InstanceExpression = new CompilerGeneratedThis (mc.CurrentType, expression.Location);
 		}
 
@@ -660,15 +660,15 @@ namespace Mono.CSharp {
 			}
 		}
 
-		public CompoundAssign (Binary.Operator op, Expression target, Expression source, Location loc)
-			: base (target, source, loc)
+		public CompoundAssign (Binary.Operator op, Expression target, Expression source)
+			: base (target, source, target.Location)
 		{
 			right = source;
 			this.op = op;
 		}
 
-		public CompoundAssign (Binary.Operator op, Expression target, Expression source, Expression left, Location loc)
-			: this (op, target, source, loc)
+		public CompoundAssign (Binary.Operator op, Expression target, Expression source, Expression left)
+			: this (op, target, source)
 		{
 			this.left = left;
 		}
@@ -731,7 +731,7 @@ namespace Mono.CSharp {
 			if (left == null)
 				left = new TargetExpression (target);
 
-			source = new Binary (op, left, right, true, loc);
+			source = new Binary (op, left, right, true);
 
 			if (target is DynamicMemberAssignable) {
 				Arguments targs = ((DynamicMemberAssignable) target).Arguments;

ICSharpCode.NRefactory.CSharp/Parser/mcs/async.cs

@@ -227,7 +227,9 @@ namespace Mono.CSharp
 			//
 			// awaiter = expr.GetAwaiter ();
 			//
-			fe_awaiter.EmitAssign (ec, expr, false, false);
+			using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
+				fe_awaiter.EmitAssign (ec, expr, false, false);
+			}
 
 			Label skip_continuation = ec.DefineLabel ();
 
@@ -284,14 +286,8 @@ namespace Mono.CSharp
 
 			awaiter.IsAvailableForReuse = true;
 
-			if (ResultType.Kind != MemberKind.Void) {
-				var storey = (AsyncTaskStorey) machine_initializer.Storey;
-
-			    if (storey.HoistedReturn != null)
-			        storey.HoistedReturn.EmitAssign (ec);
-				else
-					ec.Emit (OpCodes.Pop);
-			}
+			if (ResultType.Kind != MemberKind.Void)
+				ec.Emit (OpCodes.Pop);
 		}
 
 		void Error_WrongAwaiterPattern (ResolveContext rc, TypeSpec awaiter)

ICSharpCode.NRefactory.CSharp/Parser/mcs/attribute.cs

@@ -1016,7 +1016,7 @@ namespace Mono.CSharp {
 								if (pos_args.Count == 1 && pos_args[0].Expr is Constant) {
 									var value = ((Constant) pos_args[0].Expr).GetValue () as string;
 									if (string.IsNullOrEmpty (value))
-										Error_AttributeEmitError ("DllName cannot be empty");
+										Error_AttributeEmitError ("DllName cannot be empty or null");
 								}
 							} else if (Type == predefined.MethodImpl && pt.BuiltinType == BuiltinTypeSpec.Type.Short &&
 								!System.Enum.IsDefined (typeof (MethodImplOptions), ((Constant) arg_expr).GetValue ().ToString ())) {
@@ -1476,6 +1476,12 @@ namespace Mono.CSharp {
 			Encode (type.MemberDefinition.IsImported ? old_type.AssemblyQualifiedName : old_type.FullName);
 		}
 
+		public void EncodeTypeName (TypeContainer type)
+		{
+			Encode (type.GetSignatureForMetadata ());
+		}
+
+
 		//
 		// Encodes single property named argument per call
 		//
@@ -1629,6 +1635,10 @@ namespace Mono.CSharp {
 		// New in .NET 4.0
 		public readonly PredefinedDynamicAttribute Dynamic;
 
+		// New in .NET 4.5
+		public readonly PredefinedStateMachineAttribute AsyncStateMachine;
+		public readonly PredefinedStateMachineAttribute IteratorStateMachine;
+
 		//
 		// Optional types which are used as types and for member lookup
 		//
@@ -1690,6 +1700,11 @@ namespace Mono.CSharp {
 			StructLayout = new PredefinedAttribute (module, "System.Runtime.InteropServices", "StructLayoutAttribute");
 			FieldOffset = new PredefinedAttribute (module, "System.Runtime.InteropServices", "FieldOffsetAttribute");
 
+			AsyncStateMachine = new PredefinedStateMachineAttribute (module, "System.Runtime.CompilerServices", "AsyncStateMachineAttribute");
+			IteratorStateMachine = new PredefinedStateMachineAttribute (module, "System.Runtime.CompilerServices", "IteratorStateMachineAttribute") {
+				IsIterator = true
+			};
+
 			CallerMemberNameAttribute = new PredefinedAttribute (module, "System.Runtime.CompilerServices", "CallerMemberNameAttribute");
 			CallerLineNumberAttribute = new PredefinedAttribute (module, "System.Runtime.CompilerServices", "CallerLineNumberAttribute");
 			CallerFilePathAttribute = new PredefinedAttribute (module, "System.Runtime.CompilerServices", "CallerFilePathAttribute");
@@ -1877,6 +1892,34 @@ namespace Mono.CSharp {
 		}
 	}
 
+	public class PredefinedStateMachineAttribute : PredefinedAttribute
+	{
+		public PredefinedStateMachineAttribute (ModuleContainer module, string ns, string name)
+			: base (module, ns, name)
+		{
+		}
+
+		public bool IsIterator { get; set; }
+
+		public void EmitAttribute (MethodBuilder builder, StateMachine type)
+		{
+			var predefined_ctor = IsIterator ?
+				module.PredefinedMembers.IteratorStateMachineAttributeCtor :
+				module.PredefinedMembers.AsyncStateMachineAttributeCtor;
+
+			var ctor = predefined_ctor.Get ();
+
+			if (ctor == null)
+				return;
+
+			AttributeEncoder encoder = new AttributeEncoder ();
+			encoder.EncodeTypeName (type);
+			encoder.EncodeEmptyNamedArguments ();
+
+			builder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
+		}
+	}
+
 	public class PredefinedDynamicAttribute : PredefinedAttribute
 	{
 		MethodSpec tctor;

ICSharpCode.NRefactory.CSharp/Parser/mcs/cfold.cs

@@ -187,7 +187,7 @@ namespace Mono.CSharp {
 				//
 				if ((lt.BuiltinType == BuiltinTypeSpec.Type.Bool && right is NullLiteral) ||
 					(rt.BuiltinType == BuiltinTypeSpec.Type.Bool && left is NullLiteral)) {
-					var b = new Nullable.LiftedBinaryOperator (oper, left, right, loc).Resolve (ec);
+					var b = new Nullable.LiftedBinaryOperator (oper, left, right).Resolve (ec);
 
 					// false | null => null
 					// null | false => null
@@ -231,7 +231,7 @@ namespace Mono.CSharp {
 				//
 				if ((lt.BuiltinType == BuiltinTypeSpec.Type.Bool && right is NullLiteral) ||
 					(rt.BuiltinType == BuiltinTypeSpec.Type.Bool && left is NullLiteral)) {
-					var b = new Nullable.LiftedBinaryOperator (oper, left, right, loc).Resolve (ec);
+					var b = new Nullable.LiftedBinaryOperator (oper, left, right).Resolve (ec);
 
 					// false & null => false
 					// null & false => false
@@ -469,7 +469,7 @@ namespace Mono.CSharp {
 				if (left is NullLiteral && right is NullLiteral) {
 					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 					lifted_int.ResolveAsType (ec);
-					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 				}
 
 				if (!DoBinaryNumericPromotions (ec, ref left, ref right))
@@ -566,7 +566,7 @@ namespace Mono.CSharp {
 				if (left is NullLiteral && right is NullLiteral) {
 					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 					lifted_int.ResolveAsType (ec);
-					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 				}
 
 				if (!DoBinaryNumericPromotions (ec, ref left, ref right))
@@ -662,7 +662,7 @@ namespace Mono.CSharp {
 				if (left is NullLiteral && right is NullLiteral) {
 					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 					lifted_int.ResolveAsType (ec);
-					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 				}
 
 				if (!DoBinaryNumericPromotions (ec, ref left, ref right))
@@ -762,7 +762,7 @@ namespace Mono.CSharp {
 				if (left is NullLiteral && right is NullLiteral) {
 					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 					lifted_int.ResolveAsType (ec);
-					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 				}
 
 				if (!DoBinaryNumericPromotions (ec, ref left, ref right))
@@ -852,7 +852,7 @@ namespace Mono.CSharp {
 				if (left is NullLiteral && right is NullLiteral) {
 					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 					lifted_int.ResolveAsType (ec);
-					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 				}
 
 				IntConstant ic = right.ConvertImplicitly (ec.BuiltinTypes.Int) as IntConstant;
@@ -873,7 +873,7 @@ namespace Mono.CSharp {
 
 				// null << value => null
 				if (left is NullLiteral)
-					return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right, loc).Resolve (ec);
+					return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right).Resolve (ec);
 
 				left = left.ConvertImplicitly (ec.BuiltinTypes.Int);
 				if (left.Type.BuiltinType == BuiltinTypeSpec.Type.Int)
@@ -889,7 +889,7 @@ namespace Mono.CSharp {
 				if (left is NullLiteral && right is NullLiteral) {
 					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 					lifted_int.ResolveAsType (ec);
-					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 				}
 
 				IntConstant sic = right.ConvertImplicitly (ec.BuiltinTypes.Int) as IntConstant;
@@ -909,7 +909,7 @@ namespace Mono.CSharp {
 
 				// null >> value => null
 				if (left is NullLiteral)
-					return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right, loc).Resolve (ec);
+					return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right).Resolve (ec);
 
 				left = left.ConvertImplicitly (ec.BuiltinTypes.Int);
 				if (left.Type.BuiltinType == BuiltinTypeSpec.Type.Int)
@@ -925,7 +925,7 @@ namespace Mono.CSharp {
 					if (left.IsNull || right.IsNull) {
 						return ReducedExpression.Create (
 							new BoolConstant (ec.BuiltinTypes, left.IsNull == right.IsNull, left.Location),
-							new Binary (oper, left, right, loc));
+							new Binary (oper, left, right));
 					}
 
 					if (left is StringConstant && right is StringConstant)
@@ -969,7 +969,7 @@ namespace Mono.CSharp {
 					if (left.IsNull || right.IsNull) {
 						return ReducedExpression.Create (
 							new BoolConstant (ec.BuiltinTypes, left.IsNull != right.IsNull, left.Location),
-							new Binary (oper, left, right, loc));
+							new Binary (oper, left, right));
 					}
 
 					if (left is StringConstant && right is StringConstant)
@@ -1011,11 +1011,11 @@ namespace Mono.CSharp {
 					if (left is NullLiteral) {
 						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 						lifted_int.ResolveAsType (ec);
-						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 					}
 
 					if (left is Nullable.LiftedNull) {
-						return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right, loc).Resolve (ec);
+						return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right).Resolve (ec);
 					}
 				}
 
@@ -1051,11 +1051,11 @@ namespace Mono.CSharp {
 					if (left is NullLiteral) {
 						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 						lifted_int.ResolveAsType (ec);
-						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 					}
 
 					if (left is Nullable.LiftedNull) {
-						return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right, loc).Resolve (ec);
+						return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right).Resolve (ec);
 					}
 				}
 
@@ -1091,11 +1091,11 @@ namespace Mono.CSharp {
 					if (left is NullLiteral) {
 						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 						lifted_int.ResolveAsType (ec);
-						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 					}
 
 					if (left is Nullable.LiftedNull) {
-						return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right, loc).Resolve (ec);
+						return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right).Resolve (ec);
 					}
 				}
 
@@ -1131,11 +1131,11 @@ namespace Mono.CSharp {
 					if (left is NullLiteral) {
 						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
 						lifted_int.ResolveAsType (ec);
-						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
+						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right).Resolve (ec);
 					}
 
 					if (left is Nullable.LiftedNull) {
-						return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right, loc).Resolve (ec);
+						return (Constant) new Nullable.LiftedBinaryOperator (oper, left, right).Resolve (ec);
 					}
 				}
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/class.cs

@@ -346,6 +346,24 @@ namespace Mono.CSharp
 			return MemberName.GetSignatureForError ();
 		}
 
+		public string GetSignatureForMetadata ()
+		{
+#if STATIC
+			var name = TypeNameParser.Escape (MemberName.Basename);
+
+			if (Parent is TypeDefinition) {
+				return Parent.GetSignatureForMetadata () + "+" + name;
+			}
+
+			if (Parent != null && Parent.MemberName != null)
+				return Parent.GetSignatureForMetadata () + "." + name;
+
+			return name;
+#else
+			throw new NotImplementedException ();
+#endif
+		}
+
 		public virtual void RemoveContainer (TypeContainer cont)
 		{
 			if (containers != null)
@@ -1845,13 +1863,20 @@ namespace Mono.CSharp
 				return;
 
 			string class_indexer_name = null;
-			has_normal_indexers = true;
 
 			//
 			// Check normal indexers for consistent name, explicit interface implementation
 			// indexers are ignored
 			//
 			foreach (var indexer in indexers) {
+				//
+				// FindMembers can return unfiltered full hierarchy names
+				//
+				if (indexer.DeclaringType != spec)
+					continue;
+
+				has_normal_indexers = true;
+
 				if (class_indexer_name == null) {
 					indexer_name = class_indexer_name = indexer.Name;
 					continue;

ICSharpCode.NRefactory.CSharp/Parser/mcs/codegen.cs

@@ -944,10 +944,10 @@ namespace Mono.CSharp
 			if (method.ReturnType.Kind == MemberKind.Void && method.IsConditionallyExcluded (ec.MemberContext, loc))
 				return;
 
-			EmitPredefined (ec, method, Arguments);
+			EmitPredefined (ec, method, Arguments, loc);
 		}
 
-		public void EmitPredefined (EmitContext ec, MethodSpec method, Arguments Arguments)
+		public void EmitPredefined (EmitContext ec, MethodSpec method, Arguments Arguments, Location? loc = null)
 		{
 			Expression instance_copy = null;
 
@@ -1006,6 +1006,18 @@ namespace Mono.CSharp
 				ec.Emit (OpCodes.Constrained, InstanceExpression.Type);
 			}
 
+			if (loc != null) {
+				//
+				// Emit explicit sequence point for expressions like Foo.Bar () to help debugger to
+				// break at right place when LHS expression can be stepped-into
+				//
+				// TODO: The list is probably not comprehensive, need to do more testing
+				//
+				if (InstanceExpression is PropertyExpr || InstanceExpression is Invocation || InstanceExpression is IndexerExpr ||
+					InstanceExpression is New || InstanceExpression is DelegateInvocation)
+					ec.Mark (loc.Value);
+			}
+
 			//
 			// Set instance expression to actual result expression. When it contains await it can be
 			// picked up by caller

ICSharpCode.NRefactory.CSharp/Parser/mcs/const.cs

@@ -59,7 +59,7 @@ namespace Mono.CSharp {
 
 			if ((field_attr & FieldAttributes.InitOnly) != 0)
 				Parent.PartialContainer.RegisterFieldForInitialization (this,
-					new FieldInitializer (spec, initializer, this));
+					new FieldInitializer (this, initializer, Location));
 
 			if (declarators != null) {
 				var t = new TypeExpression (MemberType, TypeExpression.Location);

ICSharpCode.NRefactory.CSharp/Parser/mcs/context.cs

@@ -13,6 +13,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Security.Cryptography;
 
 namespace Mono.CSharp
 {
@@ -730,4 +731,28 @@ namespace Mono.CSharp
 			return new FlagsHandle (this, options, enable ? options : 0);
 		}
 	}
+
+	//
+	// Parser session objects. We could recreate all these objects for each parser
+	// instance but the best parser performance the session object can be reused
+	//
+	public class ParserSession
+	{
+		MD5 md5;
+
+		public readonly char[] StreamReaderBuffer = new char[SeekableStreamReader.DefaultReadAheadSize * 2];
+		public readonly Dictionary<char[], string>[] Identifiers = new Dictionary<char[], string>[Tokenizer.MaxIdentifierLength + 1];
+		public readonly List<Parameter> ParametersStack = new List<Parameter> (4);
+		public readonly char[] IDBuilder = new char[Tokenizer.MaxIdentifierLength];
+		public readonly char[] NumberBuilder = new char[Tokenizer.MaxNumberLength];
+
+		public LocationsBag LocationsBag { get; set; }
+		public bool UseJayGlobalArrays { get; set; }
+		public Tokenizer.LocatedToken[] LocatedTokens { get; set; }
+
+		public MD5 GetChecksumAlgorithm ()
+		{
+			return md5 ?? (md5 = MD5.Create ());
+		}
+	}
 }

ICSharpCode.NRefactory.CSharp/Parser/mcs/cs-parser.jay

@@ -76,7 +76,7 @@ namespace Mono.CSharp
 		///
 		/// An out-of-band stack.
 		///
-		static Stack<object> oob_stack;
+		Stack<object> oob_stack;
 
 		///
 		/// Controls the verbosity of the errors produced by the parser
@@ -132,7 +132,7 @@ namespace Mono.CSharp
 		// share the bucket for very common constructs which can never
 		// be recursive
 		//
-		static List<Parameter> parameters_bucket = new List<Parameter> (6);
+		List<Parameter> parameters_bucket;
 		
 		//
 		// Full AST support members
@@ -2662,6 +2662,21 @@ enum_member_declaration
 		if (doc_support)
 			em.DocComment = ConsumeStoredComment ();
 
+		$$ = em;
+	  }
+	| opt_attributes IDENTIFIER error
+	  {
+		Error_SyntaxError (yyToken);
+	  
+		var lt = (Tokenizer.LocatedToken) $2;
+	  	var em = new EnumMember ((Enum) current_type, new MemberName (lt.Value, lt.Location), (Attributes) $1);
+	  	((Enum) current_type).AddEnumMember (em);
+
+		if (doc_support) {
+			em.DocComment = Lexer.consume_doc_comment ();
+			Lexer.doc_state = XmlCommentState.Allowed;
+		}
+
 		$$ = em;
 	  }
 	| attributes_without_members
@@ -3961,18 +3976,18 @@ multiplicative_expression
 	: prefixed_unary_expression
 	| multiplicative_expression STAR prefixed_unary_expression
 	  {
-		$$ = new Binary (Binary.Operator.Multiply, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.Multiply, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| multiplicative_expression DIV prefixed_unary_expression
 	  {
-		$$ = new Binary (Binary.Operator.Division, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.Division, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| multiplicative_expression PERCENT prefixed_unary_expression 
 	  {
-		$$ = new Binary (Binary.Operator.Modulus, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.Modulus, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 
@@ -3980,18 +3995,14 @@ additive_expression
 	: multiplicative_expression
 	| additive_expression PLUS multiplicative_expression 
 	  {
-		$$ = new Binary (Binary.Operator.Addition, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.Addition, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| additive_expression MINUS multiplicative_expression
 	  {
-		$$ = new Binary (Binary.Operator.Subtraction, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.Subtraction, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
-  	| parenthesized_expression MINUS multiplicative_expression
-	  {
-	  	// Shift/Reduce conflict
-		$$ = new Binary (Binary.Operator.Subtraction, (Expression) $1, (Expression) $3, GetLocation ($2));
-  	  }
 	| additive_expression AS type
 	  {
 		$$ = new As ((Expression) $1, (Expression) $3, GetLocation ($2));
@@ -4006,13 +4017,13 @@ shift_expression
 	: additive_expression
 	| shift_expression OP_SHIFT_LEFT additive_expression
 	  {
-		$$ = new Binary (Binary.Operator.LeftShift, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.LeftShift, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| shift_expression OP_SHIFT_RIGHT additive_expression
 	  {
-		$$ = new Binary (Binary.Operator.RightShift, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.RightShift, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	; 
 
@@ -4020,23 +4031,23 @@ relational_expression
 	: shift_expression
 	| relational_expression OP_LT shift_expression
 	  {
-		$$ = new Binary (Binary.Operator.LessThan, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.LessThan, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| relational_expression OP_GT shift_expression
 	  {
-		$$ = new Binary (Binary.Operator.GreaterThan, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.GreaterThan, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| relational_expression OP_LE shift_expression
 	  {
-		$$ = new Binary (Binary.Operator.LessThanOrEqual, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.LessThanOrEqual, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| relational_expression OP_GE shift_expression
 	  {
-		$$ = new Binary (Binary.Operator.GreaterThanOrEqual, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.GreaterThanOrEqual, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 
@@ -4044,13 +4055,13 @@ equality_expression
 	: relational_expression
 	| equality_expression OP_EQ relational_expression
 	  {
-		$$ = new Binary (Binary.Operator.Equality, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.Equality, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| equality_expression OP_NE relational_expression
 	  {
-		$$ = new Binary (Binary.Operator.Inequality, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.Inequality, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	; 
 
@@ -4058,8 +4069,8 @@ and_expression
 	: equality_expression
 	| and_expression BITWISE_AND equality_expression
 	  {
-		$$ = new Binary (Binary.Operator.BitwiseAnd, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.BitwiseAnd, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 
@@ -4067,8 +4078,8 @@ exclusive_or_expression
 	: and_expression
 	| exclusive_or_expression CARRET and_expression
 	  {
-		$$ = new Binary (Binary.Operator.ExclusiveOr, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.ExclusiveOr, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 
@@ -4076,8 +4087,8 @@ inclusive_or_expression
 	: exclusive_or_expression
 	| inclusive_or_expression BITWISE_OR exclusive_or_expression
 	  {
-		$$ = new Binary (Binary.Operator.BitwiseOr, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.BitwiseOr, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 
@@ -4085,8 +4096,8 @@ conditional_and_expression
 	: inclusive_or_expression
 	| conditional_and_expression OP_AND inclusive_or_expression
 	  {
-		$$ = new Binary (Binary.Operator.LogicalAnd, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.LogicalAnd, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 
@@ -4094,8 +4105,8 @@ conditional_or_expression
 	: conditional_and_expression
 	| conditional_or_expression OP_OR conditional_and_expression
 	  {
-		$$ = new Binary (Binary.Operator.LogicalOr, 
-			         (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Binary (Binary.Operator.LogicalOr, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 	
@@ -4106,7 +4117,8 @@ null_coalescing_expression
 		if (lang_version < LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation ($2), "null coalescing operator");
 			
-		$$ = new Nullable.NullCoalescingOperator ((Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new Nullable.NullCoalescingOperator ((Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 
@@ -4127,57 +4139,58 @@ conditional_expression
 assignment_expression
 	: prefixed_unary_expression ASSIGN expression
 	  {
-		$$ = new SimpleAssign ((Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new SimpleAssign ((Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_MULT_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.Multiply, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.Multiply, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_DIV_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.Division, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.Division, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_MOD_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.Modulus, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.Modulus, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_ADD_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.Addition, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.Addition, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_SUB_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.Subtraction, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.Subtraction, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_SHIFT_LEFT_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.LeftShift, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.LeftShift, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_SHIFT_RIGHT_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.RightShift, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.RightShift, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_AND_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.BitwiseAnd, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.BitwiseAnd, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_OR_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.BitwiseOr, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.BitwiseOr, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| prefixed_unary_expression OP_XOR_ASSIGN expression
 	  {
-		$$ = new CompoundAssign (
-			Binary.Operator.ExclusiveOr, (Expression) $1, (Expression) $3, GetLocation ($2));
+		$$ = new CompoundAssign (Binary.Operator.ExclusiveOr, (Expression) $1, (Expression) $3);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	;
 
@@ -4971,7 +4984,7 @@ identifier_inside_body
 	  {
 		if (async_block) {
 			report.Error (4003, GetLocation ($1), "`await' cannot be used as an identifier within an async method or lambda expression");
-			$$ = Tokenizer.LocatedToken.Create ("await", GetLocation ($1));
+			$$ = new Tokenizer.LocatedToken ("await", GetLocation ($1));
 		}
 	  }
 	;
@@ -5353,19 +5366,19 @@ while_statement
 do_statement
 	: DO embedded_statement WHILE open_parens_any boolean_expression CLOSE_PARENS SEMICOLON
 	  {
-		$$ = new Do ((Statement) $2, (BooleanExpression) $5, GetLocation ($1));
+		$$ = new Do ((Statement) $2, (BooleanExpression) $5, GetLocation ($1), GetLocation ($3));
 		lbag.AddStatement ($$, GetLocation ($3), GetLocation ($4), GetLocation ($6), GetLocation ($7));
 	  }
 	| DO embedded_statement error
 	  {
 		Error_SyntaxError (yyToken);
-		$$ = new Do ((Statement) $2, null, GetLocation ($1));
+		$$ = new Do ((Statement) $2, null, GetLocation ($1), Location.Null);
 	  }
 	| DO embedded_statement WHILE open_parens_any boolean_expression error
 	  {
 		Error_SyntaxError (yyToken);
 	  
-		$$ = new Do ((Statement) $2, (BooleanExpression) $5, GetLocation ($1));
+		$$ = new Do ((Statement) $2, (BooleanExpression) $5, GetLocation ($1), GetLocation ($3));
 		lbag.AddStatement ($$, GetLocation ($3), GetLocation ($4));
 	  }
 	;
@@ -5634,6 +5647,11 @@ return_statement
 		$$ = new Return ((Expression) $2, GetLocation ($1));
 		lbag.AddStatement ($$, GetLocation ($3));
 	  }
+	| RETURN expression error
+	  {
+		Error_SyntaxError (yyToken);
+		$$ = new Return ((Expression) $2, GetLocation ($1));
+	  }
 	| RETURN error
 	  {
 		Error_SyntaxError (yyToken);
@@ -5671,6 +5689,24 @@ yield_statement
 		$$ = new Yield ((Expression) $3, lt.Location);
 		lbag.AddStatement ($$, GetLocation ($2), GetLocation ($4));
 	  }
+	| identifier_inside_body RETURN expression error
+	  {
+		Error_SyntaxError (yyToken);
+
+		var lt = (Tokenizer.LocatedToken) $1;
+		string s = lt.Value;
+		if (s != "yield"){
+			report.Error (1003, lt.Location, "; expected");
+		} else if ($3 == null) {
+			report.Error (1627, GetLocation ($4), "Expression expected after yield return");
+		} else if (lang_version == LanguageVersion.ISO_1){
+			FeatureIsNotAvailable (lt.Location, "iterators");
+		}
+		
+		current_block.Explicit.RegisterIteratorYield ();
+		$$ = new Yield ((Expression) $3, lt.Location);
+		lbag.AddStatement ($$, GetLocation ($2));
+	  }
 	| identifier_inside_body BREAK SEMICOLON
 	  {
 		var lt = (Tokenizer.LocatedToken) $1;
@@ -6769,17 +6805,12 @@ public Tokenizer Lexer {
 	}
 }		   
 
-static CSharpParser ()
+public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, ParserSession session)
+	: this (reader, file, file.Compiler.Report, session)
 {
-	oob_stack = new Stack<object> ();
 }
 
-public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file)
-	: this (reader, file, file.Compiler.Report)
-{
-}
-
-public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, Report report)
+public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, Report report, ParserSession session)
 {
 	this.file = file;
 	current_container = current_namespace = file;
@@ -6792,22 +6823,16 @@ public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, Re
 	lang_version = settings.Version;
 	yacc_verbose_flag = settings.VerboseParserFlag;
 	doc_support = settings.DocumentationFile != null;
-	oob_stack.Clear ();
-	lexer = new Tokenizer (reader, file);
-
-#if FULL_AST
-	lbag = new LocationsBag ();
-#else
-	lbag = null;
-#endif
-	
-	use_global_stacks = true;
+	lexer = new Tokenizer (reader, file, session);
+	oob_stack = new Stack<object> ();
+	lbag = session.LocationsBag;
+	use_global_stacks = session.UseJayGlobalArrays;
+	parameters_bucket = session.ParametersStack;
 }
 
 public void parse ()
 {
 	eof_token = Token.EOF;
-	Tokenizer.LocatedToken.Initialize ();
 	
 	try {
 		if (yacc_verbose_flag > 1)
@@ -6874,12 +6899,6 @@ Location GetLocation (object obj)
 	return lexer.Location;
 }
 
-public LocationsBag LocationsBag {
-	get {
-		return lbag;
-	}
-}
-
 void start_block (Location loc)
 {
 	if (current_block == null) {

ICSharpCode.NRefactory.CSharp/Parser/mcs/cs-tokenizer.cs

@@ -16,6 +16,7 @@ using System.Text;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Diagnostics;
+using System.Collections;
 
 namespace Mono.CSharp
 {
@@ -66,32 +67,62 @@ namespace Mono.CSharp
 		}
 
 		//
-		// This class has to be used in the parser only, it reuses token
-		// details after each parse
+		// This class has to be used by parser only, it reuses token
+		// details after each file parse completion
 		//
 		public class LocatedToken
 		{
-			int row, column;
-			string value;
+			public int row, column;
+			public string value;
+			public SourceFile file;
 
-			static LocatedToken[] buffer = new LocatedToken[0];
-			static int pos;
-
-			private LocatedToken ()
+			public LocatedToken ()
 			{
 			}
 
-			public static LocatedToken Create (int row, int column)
+			public LocatedToken (string value, Location loc)
 			{
-				return Create (null, row, column);
+				this.value = value;
+				file = loc.SourceFile;
+				row = loc.Row;
+				column = loc.Column;
 			}
 
-			public static LocatedToken Create (string value, Location loc)
+			public override string ToString ()
 			{
-				return Create (value, loc.Row, loc.Column);
+				return string.Format ("Token '{0}' at {1},{2}", Value, row, column);
 			}
 			
-			public static LocatedToken Create (string value, int row, int column)
+			public Location Location {
+				get { return new Location (file, row, column); }
+			}
+
+			public string Value {
+				get { return value; }
+			}
+		}
+
+		public class LocatedTokenBuffer
+		{
+			readonly LocatedToken[] buffer;
+			public int pos;
+
+			public LocatedTokenBuffer ()
+			{
+				buffer = new LocatedToken[0];
+			}
+
+			public LocatedTokenBuffer (LocatedToken[] buffer)
+			{
+				this.buffer = buffer ?? new LocatedToken[0];
+			}
+
+			public LocatedToken Create (SourceFile file, int row, int column)
+			{
+				return Create (null, file, row, column);
+			}
+
+			public LocatedToken Create (string value, SourceFile file, int row, int column)
 			{
 				//
 				// TODO: I am not very happy about the logic but it's the best
@@ -105,15 +136,16 @@ namespace Mono.CSharp
 				if (pos >= buffer.Length) {
 					entry = new LocatedToken ();
 				} else {
-					entry = buffer [pos];
+					entry = buffer[pos];
 					if (entry == null) {
 						entry = new LocatedToken ();
-						buffer [pos] = entry;
+						buffer[pos] = entry;
 					}
 
 					++pos;
 				}
 				entry.value = value;
+				entry.file = file;
 				entry.row = row;
 				entry.column = column;
 				return entry;
@@ -123,31 +155,9 @@ namespace Mono.CSharp
 			// Used for token not required by expression evaluator
 			//
 			[Conditional ("FULL_AST")]
-			public static void CreateOptional (int row, int col, ref object token)
+			public void CreateOptional (SourceFile file, int row, int col, ref object token)
 			{
-				token = Create (row, col);
-			}
-
-			public static void Initialize ()
-			{
-#if !FULL_AST
-				if (buffer.Length == 0)
-					buffer = new LocatedToken [15000];
-#endif
-				pos = 0;
-			}
-
-			public override string ToString ()
-			{
-				return string.Format ("Token '{0}' at {1},{2}", Value, row, column);
-			}
-			
-			public Location Location {
-				get { return new Location (row, column); }
-			}
-
-			public string Value {
-				get { return value; }
+				token = Create (file, row, col);
 			}
 		}
 
@@ -174,13 +184,7 @@ namespace Mono.CSharp
 
 		readonly SeekableStreamReader reader;
 		readonly CompilationSourceFile source_file;
-
-		public CompilationSourceFile SourceFile {
-			get {
-				return source_file;
-			}
-		}
-
+		public CompilationSourceFile SourceFile { get { return source_file; } }
 		readonly CompilerContext context;
 
 		SourceFile current_source;
@@ -199,6 +203,7 @@ namespace Mono.CSharp
 		List<Location> escaped_identifiers;
 		int parsing_generic_less_than;
 		readonly bool doc_processing;
+		readonly LocatedTokenBuffer ltb;
 		
 		//
 		// Used mainly for parser optimizations. Some expressions for instance
@@ -362,27 +367,15 @@ namespace Mono.CSharp
 		//
 		Stack<int> ifstack;
 
-		const int max_id_size = 512;
-		const int max_number_size = 512;
-
-#if FULL_AST
-		readonly char [] id_builder = new char [max_id_size];
-
-		Dictionary<char[], string>[] identifiers = new Dictionary<char[], string>[max_id_size + 1];
+		public const int MaxIdentifierLength = 512;
+		public const int MaxNumberLength = 512;
 
-		char [] number_builder = new char [max_number_size];
+		readonly char[] id_builder;
+		readonly Dictionary<char[], string>[] identifiers;
+		readonly char[] number_builder;
 		int number_pos;
 
-		char[] value_builder = new char[256];
-#else
-		static readonly char [] id_builder = new char [max_id_size];
-
-		static Dictionary<char[], string>[] identifiers = new Dictionary<char[], string>[max_id_size + 1];
-
-		static char [] number_builder = new char [max_number_size];
-		static int number_pos;
-		static char[] value_builder = new char[256];
-#endif
+		char[] value_builder = new char[64];
 
 		public int Line {
 			get {
@@ -437,11 +430,15 @@ namespace Mono.CSharp
 			}
 		}
 
-		public Tokenizer (SeekableStreamReader input, CompilationSourceFile file)
+		public Tokenizer (SeekableStreamReader input, CompilationSourceFile file, ParserSession session)
 		{
 			this.source_file = file;
 			this.context = file.Compiler;
 			this.current_source = file.SourceFile;
+			this.identifiers = session.Identifiers;
+			this.id_builder = session.IDBuilder;
+			this.number_builder = session.NumberBuilder;
+			this.ltb = new LocatedTokenBuffer (session.LocatedTokens);
 
 			reader = input;
 
@@ -451,8 +448,6 @@ namespace Mono.CSharp
 			doc_processing = context.Settings.DocumentationFile != null;
 
 			tab_size = context.Settings.TabSize;
-
-			Mono.CSharp.Location.Push (current_source);
 		}
 		
 		public void PushPosition ()
@@ -836,11 +831,13 @@ namespace Mono.CSharp
 						PushPosition ();
 						xtoken ();
 						if (xtoken () != Token.ARROW)
-							res = -1;
+							goto default;
 
 						PopPosition ();
 						break;
 					default:
+						// peek_token could overwrite id_buffer
+						id_builder [0] = 'a'; id_builder [1] = 's'; id_builder [2] = 'y'; id_builder [3] = 'n'; id_builder [4] = 'c';
 						res = -1;
 						break;
 					}
@@ -898,7 +895,7 @@ namespace Mono.CSharp
 
 		public Location Location {
 			get {
-				return new Location (ref_line, col);
+				return new Location (current_source, ref_line, col);
 			}
 		}
 
@@ -1111,9 +1108,14 @@ namespace Mono.CSharp
 		start:
 			int the_token = token ();
 			if (the_token == Token.OPEN_BRACKET) {
-				do {
+				while (true) {
 					the_token = token ();
-				} while (the_token != Token.CLOSE_BRACKET);
+					if (the_token == Token.EOF)
+						return true;
+
+					if (the_token == Token.CLOSE_BRACKET)
+						break;
+				}
 				the_token = token ();
 			} else if (the_token == Token.IN || the_token == Token.OUT) {
 				the_token = token ();
@@ -1326,7 +1328,7 @@ namespace Mono.CSharp
 			bool seen_digits = false;
 			
 			if (c != -1){
-				if (number_pos == max_number_size)
+				if (number_pos == MaxNumberLength)
 					Error_NumericConstantTooLong ();
 				number_builder [number_pos++] = (char) c;
 			}
@@ -1337,7 +1339,7 @@ namespace Mono.CSharp
 			//
 			while ((d = peek_char2 ()) != -1){
 				if (d >= '0' && d <= '9'){
-					if (number_pos == max_number_size)
+					if (number_pos == MaxNumberLength)
 						Error_NumericConstantTooLong ();
 					number_builder [number_pos++] = (char) d;
 					get_char ();
@@ -1602,23 +1604,23 @@ namespace Mono.CSharp
 			
 			if (c == 'e' || c == 'E'){
 				is_real = true;
-				if (number_pos == max_number_size)
+				if (number_pos == MaxNumberLength)
 					Error_NumericConstantTooLong ();
 				number_builder [number_pos++] = (char) c;
 				c = get_char ();
 				
 				if (c == '+'){
-					if (number_pos == max_number_size)
+					if (number_pos == MaxNumberLength)
 						Error_NumericConstantTooLong ();
 					number_builder [number_pos++] = '+';
 					c = -1;
 				} else if (c == '-') {
-					if (number_pos == max_number_size)
+					if (number_pos == MaxNumberLength)
 						Error_NumericConstantTooLong ();
 					number_builder [number_pos++] = '-';
 					c = -1;
 				} else {
-					if (number_pos == max_number_size)
+					if (number_pos == MaxNumberLength)
 						Error_NumericConstantTooLong ();
 					number_builder [number_pos++] = '+';
 				}
@@ -1967,7 +1969,7 @@ namespace Mono.CSharp
 			}
 
 			if (pos != 0) {
-				if (pos > max_id_size)
+				if (pos > MaxIdentifierLength)
 					arg = new string (value_builder, 0, pos);
 				else
 					arg = InternIdentifier (value_builder, pos);
@@ -2002,7 +2004,6 @@ namespace Mono.CSharp
 				}
 
 				//ref_line = line;
-				Location.Push (current_source);
 				return true;
 			}
 
@@ -2089,7 +2090,6 @@ namespace Mono.CSharp
 			if (new_file_name != null) {
 				current_source = context.LookupFile (source_file, new_file_name);
 				source_file.AddIncludeFile (current_source);
-				Location.Push (current_source);
 			}
 
 			if (!hidden_block_start.IsNull) {
@@ -2187,6 +2187,8 @@ namespace Mono.CSharp
 			//
 			// The syntax is ` "foo.txt" "{guid}" "hash"'
 			//
+			// guid is predefined hash algorithm guid {406ea660-64cf-4c82-b6f0-42d48172a799} for md5
+			//
 			int c = get_char ();
 
 			if (c != '"')
@@ -2249,6 +2251,7 @@ namespace Mono.CSharp
 			// Any length of checksum
 			List<byte> checksum_bytes = new List<byte> (16);
 
+			var checksum_location = Location;
 			c = peek_char ();
 			while (c != '"' && c != -1) {
 				checksum_bytes.Add (read_hex (out error));
@@ -2264,14 +2267,23 @@ namespace Mono.CSharp
 				return false;
 			}
 
-			file.SetChecksum (guid_bytes, checksum_bytes.ToArray ());
-			current_source.AutoGenerated = true;
+			if (context.Settings.GenerateDebugInfo) {
+				var chsum = checksum_bytes.ToArray ();
+
+				if (file.HasChecksum) {
+					if (!ArrayComparer.IsEqual (file.Checksum, chsum)) {
+						// TODO: Report.SymbolRelatedToPreviousError
+						Report.Warning (1697, 1, checksum_location, "Different checksum values specified for file `{0}'", file.Name);
+					}
+				}
+
+				file.SetChecksum (guid_bytes, chsum);
+				current_source.AutoGenerated = true;
+			}
+
 			return true;
 		}
 
-#if !FULL_AST
-		static
-#endif
 		bool IsTokenIdentifierEqual (char[] identifier)
 		{
 			for (int i = 0; i < identifier.Length; ++i) {
@@ -3013,7 +3025,7 @@ namespace Mono.CSharp
 			if (id_builder [0] >= '_' && !quoted) {
 				int keyword = GetKeyword (id_builder, pos);
 				if (keyword != -1) {
-					val = LocatedToken.Create (keyword == Token.AWAIT ? "await" : null, ref_line, column);
+					val = ltb.Create (keyword == Token.AWAIT ? "await" : null, current_source, ref_line, column);
 					return keyword;
 				}
 			}
@@ -3021,12 +3033,12 @@ namespace Mono.CSharp
 			string s = InternIdentifier (id_builder, pos);
 #if FULL_AST
 			if (quoted) {
-				val = LocatedToken.Create ("@" + s, ref_line, column - 1);
+				val = ltb.Create ("@" + s, current_source, ref_line, column - 1);
 			} else {
-				val = LocatedToken.Create (s, ref_line, column);
+				val = ltb.Create (s, current_source, ref_line, column);
 			}
 #else
-			val = LocatedToken.Create (s, ref_line, column);
+			val = ltb.Create (s, current_source, ref_line, column);
 #endif
 			if (quoted && parsing_attribute_section)
 				AddEscapedIdentifier (((LocatedToken) val).Location);
@@ -3034,9 +3046,6 @@ namespace Mono.CSharp
 			return Token.IDENTIFIER;
 		}
 
-#if !FULL_AST
-		static
-#endif
 		string InternIdentifier (char[] charBuffer, int length)
 		{
 			//
@@ -3102,17 +3111,17 @@ namespace Mono.CSharp
 					return consume_identifier (c);
 
 				case '{':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					return Token.OPEN_BRACE;
 				case '}':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					return Token.CLOSE_BRACE;
 				case '[':
 					// To block doccomment inside attribute declaration.
 					if (doc_state == XmlCommentState.Allowed)
 						doc_state = XmlCommentState.NotAllowed;
 
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 
 					if (parsing_block == 0 || lambda_arguments_parsing)
 						return Token.OPEN_BRACKET;
@@ -3138,10 +3147,10 @@ namespace Mono.CSharp
 						return Token.OPEN_BRACKET_EXPR;
 					}
 				case ']':
-					LocatedToken.CreateOptional (ref_line, col, ref val);
+					ltb.CreateOptional (current_source, ref_line, col, ref val);
 					return Token.CLOSE_BRACKET;
 				case '(':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					//
 					// An expression versions of parens can appear in block context only
 					//
@@ -3186,29 +3195,29 @@ namespace Mono.CSharp
 
 					return Token.OPEN_PARENS;
 				case ')':
-					LocatedToken.CreateOptional (ref_line, col, ref val);
+					ltb.CreateOptional (current_source, ref_line, col, ref val);
 					return Token.CLOSE_PARENS;
 				case ',':
-					LocatedToken.CreateOptional (ref_line, col, ref val);
+					ltb.CreateOptional (current_source, ref_line, col, ref val);
 					return Token.COMMA;
 				case ';':
-					LocatedToken.CreateOptional (ref_line, col, ref val);
+					ltb.CreateOptional (current_source, ref_line, col, ref val);
 					return Token.SEMICOLON;
 				case '~':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					return Token.TILDE;
 				case '?':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					return TokenizePossibleNullableType ();
 				case '<':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					if (parsing_generic_less_than++ > 0)
 						return Token.OP_GENERICS_LT;
 
 					return TokenizeLessThan ();
 
 				case '>':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					d = peek_char ();
 
 					if (d == '=') {
@@ -3235,7 +3244,7 @@ namespace Mono.CSharp
 					return Token.OP_GT;
 
 				case '+':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					d = peek_char ();
 					if (d == '+') {
 						d = Token.OP_INC;
@@ -3248,7 +3257,7 @@ namespace Mono.CSharp
 					return d;
 
 				case '-':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					d = peek_char ();
 					if (d == '-') {
 						d = Token.OP_DEC;
@@ -3263,15 +3272,15 @@ namespace Mono.CSharp
 					return d;
 
 				case '!':
-					val = LocatedToken.Create (ref_line, col);
-					if (peek_char () == '=') {
+					val = ltb.Create (current_source, ref_line, col);
+					if (peek_char () == '='){
 						get_char ();
 						return Token.OP_NE;
 					}
 					return Token.BANG;
 
 				case '=':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					d = peek_char ();
 					if (d == '=') {
 						get_char ();
@@ -3285,7 +3294,7 @@ namespace Mono.CSharp
 					return Token.ASSIGN;
 
 				case '&':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					d = peek_char ();
 					if (d == '&') {
 						get_char ();
@@ -3298,7 +3307,7 @@ namespace Mono.CSharp
 					return Token.BITWISE_AND;
 
 				case '|':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					d = peek_char ();
 					if (d == '|') {
 						get_char ();
@@ -3311,8 +3320,8 @@ namespace Mono.CSharp
 					return Token.BITWISE_OR;
 
 				case '*':
-					val = LocatedToken.Create (ref_line, col);
-					if (peek_char () == '=') {
+					val = ltb.Create (current_source, ref_line, col);
+					if (peek_char () == '='){
 						get_char ();
 						return Token.OP_MULT_ASSIGN;
 					}
@@ -3320,8 +3329,8 @@ namespace Mono.CSharp
 
 				case '/':
 					d = peek_char ();
-					if (d == '=') {
-						val = LocatedToken.Create (ref_line, col);
+					if (d == '='){
+						val = ltb.Create (current_source, ref_line, col);
 						get_char ();
 						return Token.OP_DIV_ASSIGN;
 					}
@@ -3430,11 +3439,11 @@ namespace Mono.CSharp
 							update_formatted_doc_comment (current_comment_start);
 						continue;
 					}
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					return Token.DIV;
 
 				case '%':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					if (peek_char () == '='){
 						get_char ();
 						return Token.OP_MOD_ASSIGN;
@@ -3442,7 +3451,7 @@ namespace Mono.CSharp
 					return Token.PERCENT;
 
 				case '^':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					if (peek_char () == '='){
 						get_char ();
 						return Token.OP_XOR_ASSIGN;
@@ -3450,7 +3459,7 @@ namespace Mono.CSharp
 					return Token.CARRET;
 
 				case ':':
-					val = LocatedToken.Create (ref_line, col);
+					val = ltb.Create (current_source, ref_line, col);
 					if (peek_char () == ':') {
 						get_char ();
 						return Token.DOUBLE_COLON;
@@ -3474,7 +3483,7 @@ namespace Mono.CSharp
 					if (d >= '0' && d <= '9')
 						return is_number (c);
 
-					LocatedToken.CreateOptional (ref_line, col, ref val);
+					ltb.CreateOptional (current_source, ref_line, col, ref val);
 					return Token.DOT;
 				
 				case '#':

ICSharpCode.NRefactory.CSharp/Parser/mcs/decl.cs

@@ -608,7 +608,7 @@ namespace Mono.CSharp {
 						if (al == Modifiers.PRIVATE) {
 							var decl = mc.Parent;
 							do {
-								same_access_restrictions = decl.CurrentType == p_parent;
+								same_access_restrictions = decl.CurrentType.MemberDefinition == p_parent.MemberDefinition;
 							} while (!same_access_restrictions && !decl.PartialContainer.IsTopLevel && (decl = decl.Parent) != null);
 						}
 						

ICSharpCode.NRefactory.CSharp/Parser/mcs/delegate.cs

@@ -520,8 +520,11 @@ namespace Mono.CSharp {
 			}
 
 			TypeSpec rt = delegate_method.ReturnType;
+			if (rt.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
+				rt = ec.BuiltinTypes.Object;
+
 			if (!Delegate.IsTypeCovariant (ec, rt, invoke_method.ReturnType)) {
-				Expression ret_expr = new TypeExpression (rt, loc);
+				Expression ret_expr = new TypeExpression (delegate_method.ReturnType, loc);
 				Error_ConversionFailed (ec, delegate_method, ret_expr);
 			}
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/doc.cs

@@ -47,6 +47,8 @@ namespace Mono.CSharp
 		//
 		Dictionary<string, XmlDocument> StoredDocuments = new Dictionary<string, XmlDocument> ();
 
+		ParserSession session;
+
 		public DocumentationBuilder (ModuleContainer module)
 		{
 			doc_module = new ModuleContainer (module.Compiler);
@@ -56,11 +58,6 @@ namespace Mono.CSharp
 			XmlDocumentation = new XmlDocument ();
 			XmlDocumentation.PreserveWhitespace = false;
 		}
-		
-		internal DocumentationBuilder()
-		{
-			// for NRefactory CSharpParser.ParseDocumentationReference
-		}
 
 		Report Report {
 			get {
@@ -329,12 +326,18 @@ namespace Mono.CSharp
 
 			var encoding = module.Compiler.Settings.Encoding;
 			var s = new MemoryStream (encoding.GetBytes (cref));
-			SeekableStreamReader seekable = new SeekableStreamReader (s, encoding);
 
-			var source_file = new CompilationSourceFile (doc_module);
+			var source_file = new CompilationSourceFile (doc_module, mc.Location.SourceFile);
 			var report = new Report (doc_module.Compiler, new NullReportPrinter ());
 
-			var parser = new CSharpParser (seekable, source_file, report);
+			if (session == null)
+				session = new ParserSession () {
+					UseJayGlobalArrays = true
+				};
+
+			SeekableStreamReader seekable = new SeekableStreamReader (s, encoding, session.StreamReaderBuffer);
+
+			var parser = new CSharpParser (seekable, source_file, report, session);
 			ParsedParameters = null;
 			ParsedName = null;
 			ParsedBuiltinType = null;

ICSharpCode.NRefactory.CSharp/Parser/mcs/driver.cs

@@ -20,6 +20,7 @@ using System.IO;
 using System.Text;
 using System.Globalization;
 using System.Diagnostics;
+using System.Threading;
 
 namespace Mono.CSharp
 {
@@ -41,7 +42,7 @@ namespace Mono.CSharp
 			}
 		}
 
-		void tokenize_file (SourceFile sourceFile, ModuleContainer module)
+		void tokenize_file (SourceFile sourceFile, ModuleContainer module, ParserSession session)
 		{
 			Stream input;
 
@@ -56,7 +57,7 @@ namespace Mono.CSharp
 				SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
 				var file = new CompilationSourceFile (module, sourceFile);
 
-				Tokenizer lexer = new Tokenizer (reader, file);
+				Tokenizer lexer = new Tokenizer (reader, file, session);
 				int token, tokens = 0, errors = 0;
 
 				while ((token = lexer.token ()) != Token.EOF){
@@ -77,48 +78,95 @@ namespace Mono.CSharp
 
 			Location.Initialize (sources);
 
+			var session = new ParserSession () {
+				UseJayGlobalArrays = true,
+				LocatedTokens = new Tokenizer.LocatedToken[15000]
+			};
+
 			for (int i = 0; i < sources.Count; ++i) {
 				if (tokenize_only) {
-					tokenize_file (sources[i], module);
+					tokenize_file (sources[i], module, session);
 				} else {
-					Parse (sources[i], module);
+					Parse (sources[i], module, session, Report);
 				}
 			}
 		}
 
-		public void Parse (SourceFile file, ModuleContainer module)
+#if false
+		void ParseParallel (ModuleContainer module)
+		{
+			var sources = module.Compiler.SourceFiles;
+
+			Location.Initialize (sources);
+
+			var pcount = Environment.ProcessorCount;
+			var threads = new Thread[System.Math.Max (2, pcount - 1)];
+
+			for (int i = 0; i < threads.Length; ++i) {
+				var t = new Thread (l => {
+					var session = new ParserSession () {
+						//UseJayGlobalArrays = true,
+					};
+
+					var report = new Report (ctx, Report.Printer); // TODO: Implement flush at once printer
+
+					for (int ii = (int) l; ii < sources.Count; ii += threads.Length) {
+						Parse (sources[ii], module, session, report);
+					}
+
+					// TODO: Merge warning regions
+				});
+
+				t.Start (i);
+				threads[i] = t;
+			}
+
+			for (int t = 0; t < threads.Length; ++t) {
+				threads[t].Join ();
+			}
+		}
+#endif
+
+		public void Parse (SourceFile file, ModuleContainer module, ParserSession session, Report report)
 		{
 			Stream input;
 
 			try {
 				input = File.OpenRead (file.Name);
 			} catch {
-				Report.Error (2001, "Source file `{0}' could not be found", file.Name);
+				report.Error (2001, "Source file `{0}' could not be found", file.Name);
 				return;
 			}
 
 			// Check 'MZ' header
 			if (input.ReadByte () == 77 && input.ReadByte () == 90) {
 
-				Report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
+				report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
 				input.Close ();
 				return;
 			}
 
 			input.Position = 0;
-			SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
+			SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding, session.StreamReaderBuffer);
+
+			Parse (reader, file, module, session, report);
+
+			if (ctx.Settings.GenerateDebugInfo && report.Errors == 0 && !file.HasChecksum) {
+				input.Position = 0;
+				var checksum = session.GetChecksumAlgorithm ();
+				file.SetChecksum (checksum.ComputeHash (input));
+			}
 
-			Parse (reader, file, module);
 			reader.Dispose ();
 			input.Close ();
 		}
 
-		public static CSharpParser Parse(SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module, int lineModifier = 0)
+		public static CSharpParser Parse (SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module, ParserSession session, Report report, int lineModifier = 0)
 		{
 			var file = new CompilationSourceFile (module, sourceFile);
 			module.AddTypeContainer(file);
 
-			CSharpParser parser = new CSharpParser (reader, file);
+			CSharpParser parser = new CSharpParser (reader, file, report, session);
 			parser.Lexer.Line += lineModifier;
 			parser.Lexer.sbag = new SpecialsBag ();
 			parser.parse ();
@@ -347,7 +395,8 @@ namespace Mono.CSharp
 			tr.Stop (TimeReporter.TimerType.CloseTypes);
 
 			tr.Start (TimeReporter.TimerType.Resouces);
-			assembly.EmbedResources ();
+			if (!settings.WriteMetadataOnly)
+				assembly.EmbedResources ();
 			tr.Stop (TimeReporter.TimerType.Resouces);
 
 			if (Report.Errors > 0)

ICSharpCode.NRefactory.CSharp/Parser/mcs/dynamic.cs

@@ -502,7 +502,7 @@ namespace Mono.CSharp
 
 			using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
 				if (s.Resolve (bc)) {
-					Statement init = new If (new Binary (Binary.Operator.Equality, site_field_expr, new NullLiteral (loc), loc), s, loc);
+					Statement init = new If (new Binary (Binary.Operator.Equality, site_field_expr, new NullLiteral (loc)), s, loc);
 					init.Emit (ec);
 				}
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/ecore.cs

@@ -2277,9 +2277,11 @@ namespace Mono.CSharp {
 				}
 			}
 
+			var report = ctx.Module.Compiler.Report;
+
 			var retval = ctx.LookupNamespaceOrType (Name, Arity, LookupMode.IgnoreAccessibility, loc);
 			if (retval != null) {
-				ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (retval.Type);
+				report.SymbolRelatedToPreviousError (retval.Type);
 				ErrorIsInaccesible (ctx, retval.GetSignatureForError (), loc);
 				return;
 			}
@@ -2290,7 +2292,17 @@ namespace Mono.CSharp {
 				return;
 			}
 
-			NamespaceContainer.Error_NamespaceNotFound (loc, Name, ctx.Module.Compiler.Report);
+			var ns_candidates = ctx.Module.GlobalRootNamespace.FindTypeNamespaces (ctx, Name, Arity);
+			if (ns_candidates != null) {
+				string usings = string.Join ("' or `", ns_candidates.ToArray ());
+				report.Error (246, loc,
+					"The type or namespace name `{0}' could not be found. Are you missing `{1}' using directive?",
+					Name, usings);
+			} else {
+				report.Error (246, loc,
+					"The type or namespace name `{0}' could not be found. Are you missing an assembly reference?",
+					Name);
+			}
 		}
 
 		public override FullNamedExpression ResolveAsTypeOrNamespace (IMemberContext ec)
@@ -3176,8 +3188,12 @@ namespace Mono.CSharp {
 			}
 
 			var me = ExtensionExpression as MemberExpr;
-			if (me != null)
+			if (me != null) {
 				me.ResolveInstanceExpression (ec, null);
+				var fe = me as FieldExpr;
+				if (fe != null)
+					fe.Spec.MemberDefinition.SetIsUsed ();
+			}
 
 			InstanceExpression = null;
 			return this;
@@ -3447,6 +3463,21 @@ namespace Mono.CSharp {
 				best_candidate_return = best_candidate.ReturnType;
 			}
 
+			if (best_candidate.IsGeneric && TypeParameterSpec.HasAnyTypeParameterConstrained (best_candidate.GenericDefinition)) {
+				ConstraintChecker cc = new ConstraintChecker (ec);
+				cc.CheckAll (best_candidate.GetGenericMethodDefinition (), best_candidate.TypeArguments, best_candidate.Constraints, loc);
+			}
+
+			//
+			// Additional check for possible imported base override method which
+			// could not be done during IsOverrideMethodBaseTypeAccessible
+			//
+			if (best_candidate.IsVirtual && (best_candidate.DeclaringType.Modifiers & Modifiers.PROTECTED) != 0 &&
+				best_candidate.MemberDefinition.IsImported && !best_candidate.DeclaringType.IsAccessible (ec)) {
+				ec.Report.SymbolRelatedToPreviousError (best_candidate);
+				ErrorIsInaccesible (ec, best_candidate.GetSignatureForError (), loc);
+			}
+
 			return this;
 		}
 
@@ -3738,7 +3769,9 @@ namespace Mono.CSharp {
 				if (!TypeSpecComparer.Equals (p_m.Parameters.Types, q_m.Parameters.Types))
 					return 0;
 
+				var orig_p = p;
 				p = p_m.ReturnType;
+				var orig_q = q;
 				q = q_m.ReturnType;
 
 				//
@@ -3755,14 +3788,14 @@ namespace Mono.CSharp {
 					return p.Kind != MemberKind.Void ? 1: 0;
 				}
 
+				var am = (AnonymousMethodExpression) a.Expr;
+
 				//
 				// When anonymous method is an asynchronous, and P has a return type Task<Y1>, and Q has a return type Task<Y2>
 				// better conversion is performed between underlying types Y1 and Y2
 				//
 				if (p.IsGenericTask || q.IsGenericTask) {
-					var async_am = a.Expr as AnonymousMethodExpression;
-					if (async_am != null && async_am.Block.IsAsync) {
-
+					if (am.Block.IsAsync) {
 						if (p.IsGenericTask != q.IsGenericTask) {
 							return 0;
 						}
@@ -3770,6 +3803,19 @@ namespace Mono.CSharp {
 						q = q.TypeArguments[0];
 						p = p.TypeArguments[0];
 					}
+				} else if (q != p) {
+					//
+					// LAMESPEC: Lambda expression returning dynamic type has identity (better) conversion to delegate returning object type
+					//
+					if (q.BuiltinType == BuiltinTypeSpec.Type.Object) {
+						var am_rt = am.InferReturnType (ec, null, orig_q);
+						if (am_rt != null && am_rt.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
+							return 2;
+					} else if (p.BuiltinType == BuiltinTypeSpec.Type.Object) {
+						var am_rt = am.InferReturnType (ec, null, orig_p);
+						if (am_rt != null && am_rt.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
+							return 1;
+					}
 				}
 
 				//
@@ -4048,6 +4094,32 @@ namespace Mono.CSharp {
 			return false;
 		}
 
+		static bool CheckInflatedArguments (MethodSpec ms)
+		{
+			if (!TypeParameterSpec.HasAnyTypeParameterTypeConstrained (ms.GenericDefinition))
+				return true;
+
+			// Setup constraint checker for probing only
+			ConstraintChecker cc = new ConstraintChecker (null);
+
+			var mp = ms.Parameters.Types;
+			for (int i = 0; i < mp.Length; ++i) {
+				var type = mp[i] as InflatedTypeSpec;
+				if (type == null)
+					continue;
+
+				var targs = type.TypeArguments;
+				if (targs.Length == 0)
+					continue;
+
+				// TODO: Checking inflated MVAR arguments should be enough
+				if (!cc.CheckAll (type.GetDefinition (), targs, type.Constraints, Location.Null))
+					return false;
+			}
+
+			return true;
+		}
+
 		public static void Error_ConstructorMismatch (ResolveContext rc, TypeSpec type, int argCount, Location loc)
 		{
 			rc.Report.Error (1729, loc,
@@ -4203,9 +4275,6 @@ namespace Mono.CSharp {
 			TypeSpec[] ptypes;
 			var ms = candidate as MethodSpec;
 			if (ms != null && ms.IsGeneric) {
-				// Setup constraint checker for probing only
-				ConstraintChecker cc = new ConstraintChecker (null);
-
 				if (type_arguments != null) {
 					var g_args_count = ms.Arity;
 					if (g_args_count != type_arguments.Count)
@@ -4251,14 +4320,12 @@ namespace Mono.CSharp {
 					if (i_args.Length != 0) {
 						ms = ms.MakeGenericMethod (ec, i_args);
 					}
-
-					cc.IgnoreInferredDynamic = true;
 				}
 
 				//
 				// Type arguments constraints have to match for the method to be applicable
 				//
-				if (!cc.CheckAll (ms.GetGenericMethodDefinition (), ms.TypeArguments, ms.Constraints, loc)) {
+				if (!CheckInflatedArguments (ms)) {
 					candidate = ms;
 					return int.MaxValue - 25000;
 				}
@@ -4485,7 +4552,7 @@ namespace Mono.CSharp {
 					return p;
 				if (specific == ac_q.Element)
 					return q;
-			} else if (TypeManager.IsGenericType (p)) {
+			} else if (p.IsGeneric && q.IsGeneric) {
 				var pargs = TypeManager.GetTypeArguments (p);
 				var qargs = TypeManager.GetTypeArguments (q);
 
@@ -4721,6 +4788,17 @@ namespace Mono.CSharp {
 						args [0].Type.GetSignatureForError (), best_candidate.Name, best_candidate.GetSignatureForError ());
 				}
 
+				//
+				// Check type constraints only when explicit type arguments are used
+				//
+				if (best_candidate.IsGeneric && type_arguments != null) {
+					MethodSpec bc = best_candidate as MethodSpec;
+					if (bc != null && TypeParameterSpec.HasAnyTypeParameterConstrained (bc.GenericDefinition)) {
+						ConstraintChecker cc = new ConstraintChecker (rc);
+						cc.CheckAll (bc.GetGenericMethodDefinition (), bc.TypeArguments, bc.Constraints, loc);
+					}
+				}
+
 				BestCandidateIsDynamic = true;
 				return null;
 			}
@@ -5279,6 +5357,8 @@ namespace Mono.CSharp {
 
 		protected override Expression DoResolve (ResolveContext ec)
 		{
+			spec.MemberDefinition.SetIsUsed ();
+
 			return DoResolve (ec, null);
 		}
 
@@ -5498,8 +5578,6 @@ namespace Mono.CSharp {
 		{
 			bool is_volatile = (spec.Modifiers & Modifiers.VOLATILE) != 0;
 
-			spec.MemberDefinition.SetIsUsed ();
-			
 			if (IsStatic){
 				if (is_volatile)
 					ec.Emit (OpCodes.Volatile);

ICSharpCode.NRefactory.CSharp/Parser/mcs/eval.cs

@@ -79,7 +79,7 @@ namespace Mono.CSharp
 			module = new ModuleContainer (ctx);
 			module.Evaluator = this;
 
-			source_file = new CompilationSourceFile (module);
+			source_file = new CompilationSourceFile (module, null);
 			module.AddTypeContainer (source_file);
 
 			startup_files = ctx.SourceFiles.Count;
@@ -115,9 +115,10 @@ namespace Mono.CSharp
 
 			Location.Initialize (ctx.SourceFiles);
 
+			var parser_session = new ParserSession ();
 			for (int i = 0; i < startup_files; ++i) {
 				var sf = ctx.SourceFiles [i];
-				d.Parse (sf, module);
+				d.Parse (sf, module, parser_session, ctx.Report);
 			}
 		}
 
@@ -442,7 +443,7 @@ namespace Mono.CSharp
 		//
 		InputKind ToplevelOrStatement (SeekableStreamReader seekable)
 		{
-			Tokenizer tokenizer = new Tokenizer (seekable, source_file);
+			Tokenizer tokenizer = new Tokenizer (seekable, source_file, new ParserSession ());
 			
 			int t = tokenizer.token ();
 			switch (t){
@@ -571,7 +572,7 @@ namespace Mono.CSharp
 			seekable.Position = 0;
 
 			source_file.DeclarationFound = false;
-			CSharpParser parser = new CSharpParser (seekable, source_file);
+			CSharpParser parser = new CSharpParser (seekable, source_file, new ParserSession ());
 
 			if (kind == InputKind.StatementOrExpression){
 				parser.Lexer.putback_char = Tokenizer.EvalStatementParserCharacter;

ICSharpCode.NRefactory.CSharp/Parser/mcs/expression.cs

@@ -1211,7 +1211,7 @@ namespace Mono.CSharp
 
 			var one = new IntConstant (ec.BuiltinTypes, 1, loc);
 			var op = IsDecrement ? Binary.Operator.Subtraction : Binary.Operator.Addition;
-			operation = new Binary (op, source, one, loc);
+			operation = new Binary (op, source, one);
 			operation = operation.Resolve (ec);
 			if (operation == null)
 				throw new NotImplementedException ("should not be reached");
@@ -1527,7 +1527,7 @@ namespace Mono.CSharp
 						// Turn is check into simple null check for implicitly convertible reference types
 						//
 						return ReducedExpression.Create (
-							new Binary (Binary.Operator.Inequality, expr, new NullLiteral (loc), loc).Resolve (ec),
+							new Binary (Binary.Operator.Inequality, expr, new NullLiteral (loc)).Resolve (ec),
 							this).Resolve (ec);
 					}
 
@@ -2014,7 +2014,7 @@ namespace Mono.CSharp
 				// b = b.left >> b.right & (0x1f|0x3f)
 				//
 				b.right = new Binary (Operator.BitwiseAnd,
-					b.right, new IntConstant (ec.BuiltinTypes, right_mask, b.right.Location), b.loc).Resolve (ec);
+					b.right, new IntConstant (ec.BuiltinTypes, right_mask, b.right.Location)).Resolve (ec);
 
 				//
 				// Expression tree representation does not use & mask
@@ -2202,19 +2202,19 @@ namespace Mono.CSharp
 		protected State state;
 		Expression enum_conversion;
 
-		public Binary (Operator oper, Expression left, Expression right, bool isCompound, Location loc)
-			: this (oper, left, right, loc)
+		public Binary (Operator oper, Expression left, Expression right, bool isCompound)
+			: this (oper, left, right)
 		{
 			if (isCompound)
 				state |= State.Compound;
 		}
 
-		public Binary (Operator oper, Expression left, Expression right, Location loc)
+		public Binary (Operator oper, Expression left, Expression right)
 		{
 			this.oper = oper;
 			this.left = left;
 			this.right = right;
-			this.loc = loc;
+			this.loc = left.Location;
 		}
 
 		#region Properties
@@ -2319,7 +2319,7 @@ namespace Mono.CSharp
 
 		public static void Error_OperatorCannotBeApplied (ResolveContext ec, Expression left, Expression right, Operator oper, Location loc)
 		{
-			new Binary (oper, left, right, loc).Error_OperatorCannotBeApplied (ec, left, right);
+			new Binary (oper, left, right).Error_OperatorCannotBeApplied (ec, left, right);
 		}
 
 		public static void Error_OperatorCannotBeApplied (ResolveContext ec, Expression left, Expression right, string oper, Location loc)
@@ -3031,7 +3031,7 @@ namespace Mono.CSharp
 				(TypeSpec.IsValueType (left.Type) && right is NullLiteral) ||
 				(right.Type.IsNullableType && (left is NullLiteral || left.Type.IsNullableType || TypeSpec.IsValueType (left.Type))) ||
 				(TypeSpec.IsValueType (right.Type) && left is NullLiteral))) {
-				var lifted = new Nullable.LiftedBinaryOperator (oper, left, right, loc);
+				var lifted = new Nullable.LiftedBinaryOperator (oper, left, right);
 				lifted.state = state;
 				return lifted.Resolve (ec);
 			}
@@ -4409,7 +4409,7 @@ namespace Mono.CSharp
 					
 					// TODO: Should be the checks resolve context sensitive?
 					ResolveContext rc = new ResolveContext (ec.MemberContext, ResolveContext.Options.UnsafeScope);
-					right = new Binary (Binary.Operator.Multiply, right, right_const, loc).Resolve (rc);
+					right = new Binary (Binary.Operator.Multiply, right, right_const).Resolve (rc);
 					if (right == null)
 						return;
 				}
@@ -5264,8 +5264,10 @@ namespace Mono.CSharp
 		{
 			this.expr = expr;		
 			this.arguments = arguments;
-			if (expr != null)
-				loc = expr.Location;
+			if (expr != null) {
+				var ma = expr as MemberAccess;
+				loc = ma != null ? ma.GetLeftExpressionLocation () : expr.Location;
+			}
 		}
 
 		#region Properties
@@ -6154,7 +6156,7 @@ namespace Mono.CSharp
 		{
 			if (initializers != null && bounds == null) {
 				//
-				// We use this to store all the date values in the order in which we
+				// We use this to store all the data values in the order in which we
 				// will need to store them in the byte blob later
 				//
 				array_data = new List<Expression> ();
@@ -6212,7 +6214,16 @@ namespace Mono.CSharp
 						ec.Report.Error (623, loc, "Array initializers can only be used in a variable or field initializer. Try using a new expression instead");
 						return false;
 					}
-					
+
+					// When we don't have explicitly specified dimensions, record whatever dimension we first encounter at each level
+					if (!bounds.ContainsKey(idx + 1))
+						bounds[idx + 1] = sub_probe.Count;
+
+					if (bounds[idx + 1] != sub_probe.Count) {
+						ec.Report.Error(847, sub_probe.Location, "An array initializer of length `{0}' was expected", bounds[idx + 1].ToString());
+						return false;
+					}
+
 					bool ret = CheckIndices (ec, sub_probe, idx + 1, specified_dims, child_bounds - 1);
 					if (!ret)
 						return false;
@@ -7932,6 +7943,18 @@ namespace Mono.CSharp
 				expr.Error_OperatorCannotBeApplied (rc, loc, ".", type);
 		}
 
+		public Location GetLeftExpressionLocation ()
+		{
+			Expression expr = LeftExpression;
+			MemberAccess ma = expr as MemberAccess;
+			while (ma != null && ma.LeftExpression != null) {
+				expr = ma.LeftExpression;
+				ma = expr as MemberAccess;
+			}
+
+			return expr == null ? Location : expr.Location;
+		}
+
 		public static bool IsValidDotExpression (TypeSpec type)
 		{
 			const MemberKind dot_kinds = MemberKind.Class | MemberKind.Struct | MemberKind.Delegate | MemberKind.Enum |
@@ -8252,9 +8275,19 @@ namespace Mono.CSharp
 		{
 			if (ec.Module.Compiler.Settings.Version > LanguageVersion.ISO_2 && !ec.IsRuntimeBinder && MethodGroupExpr.IsExtensionMethodArgument (expr)) {
 				ec.Report.SymbolRelatedToPreviousError (type);
+
+				var cand = ec.Module.GlobalRootNamespace.FindExtensionMethodNamespaces (ec, type, name, Arity);
+				string missing;
+				// a using directive or an assembly reference
+				if (cand != null) {
+					missing = "`" + string.Join ("' or `", cand.ToArray ()) + "' using directive";
+				} else {
+					missing = "an assembly reference";
+				}
+
 				ec.Report.Error (1061, loc,
-					"Type `{0}' does not contain a definition for `{1}' and no extension method `{1}' of type `{0}' could be found (are you missing a using directive or an assembly reference?)",
-					type.GetSignatureForError (), name);
+					"Type `{0}' does not contain a definition for `{1}' and no extension method `{1}' of type `{0}' could be found. Are you missing {2}?",
+					type.GetSignatureForError (), name, missing);
 				return;
 			}
 
@@ -9461,7 +9494,7 @@ namespace Mono.CSharp
 
 			this.left = left;
 			this.spec = spec;
-			this.loc = spec.Location;
+			this.loc = left.Location;
 		}
 
 		public override TypeSpec ResolveAsType (IMemberContext ec)

ICSharpCode.NRefactory.CSharp/Parser/mcs/field.cs

@@ -640,13 +640,12 @@ namespace Mono.CSharp
 			}
 
 			if (initializer != null) {
-				Parent.RegisterFieldForInitialization (this,
-					new FieldInitializer (spec, initializer, this));
+				Parent.RegisterFieldForInitialization (this, new FieldInitializer (this, initializer, TypeExpression.Location));
 			}
 
 			if (declarators != null) {
-				var t = new TypeExpression (MemberType, TypeExpression.Location);
 				foreach (var d in declarators) {
+					var t = new TypeExpression (MemberType, d.Name.Location);
 					var f = new Field (Parent, t, ModFlags, new MemberName (d.Name.Value, d.Name.Location), OptAttributes);
 					if (d.Initializer != null)
 						f.initializer = d.Initializer;

ICSharpCode.NRefactory.CSharp/Parser/mcs/generic.cs

@@ -737,6 +737,12 @@ namespace Mono.CSharp {
 			}
 		}
 
+		public bool HasAnyTypeConstraint {
+			get {
+				return (spec & (SpecialConstraint.Class | SpecialConstraint.Struct)) != 0 || ifaces != null || targs != null || HasTypeConstraint;
+			}
+		}
+
 		public bool HasTypeConstraint {
 			get {
 				var bt = BaseType.BuiltinType;
@@ -1226,6 +1232,30 @@ namespace Mono.CSharp {
 			return false;
 		}
 
+		public static bool HasAnyTypeParameterTypeConstrained (IGenericMethodDefinition md)
+		{
+			var tps = md.TypeParameters;
+			for (int i = 0; i < md.TypeParametersCount; ++i) {
+				if (tps[i].HasAnyTypeConstraint) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		public static bool HasAnyTypeParameterConstrained (IGenericMethodDefinition md)
+		{
+			var tps = md.TypeParameters;
+			for (int i = 0; i < md.TypeParametersCount; ++i) {
+				if (tps[i].IsConstrained) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
 		public override TypeSpec Mutate (TypeParameterMutator mutator)
 		{
 			return mutator.Mutate (this);
@@ -2224,29 +2254,14 @@ namespace Mono.CSharp {
 	struct ConstraintChecker
 	{
 		IMemberContext mc;
-		bool ignore_inferred_dynamic;
 		bool recursive_checks;
 
 		public ConstraintChecker (IMemberContext ctx)
 		{
 			this.mc = ctx;
-			ignore_inferred_dynamic = false;
 			recursive_checks = false;
 		}
 
-		#region Properties
-
-		public bool IgnoreInferredDynamic {
-			get {
-				return ignore_inferred_dynamic;
-			}
-			set {
-				ignore_inferred_dynamic = value;
-			}
-		}
-
-		#endregion
-
 		//
 		// Checks the constraints of open generic type against type
 		// arguments. This version is used for types which could not be
@@ -2296,9 +2311,6 @@ namespace Mono.CSharp {
 		public bool CheckAll (MemberSpec context, TypeSpec[] targs, TypeParameterSpec[] tparams, Location loc)
 		{
 			for (int i = 0; i < tparams.Length; i++) {
-				if (ignore_inferred_dynamic && targs[i].BuiltinType == BuiltinTypeSpec.Type.Dynamic)
-					continue;
-
 				var targ = targs[i];
 				if (!CheckConstraint (context, targ, tparams [i], loc))
 					return false;
@@ -2446,14 +2458,6 @@ namespace Mono.CSharp {
 					return true;
 			}
 
-			//
-			// When partial/full type inference finds a dynamic type argument delay
-			// the constraint check to runtime, it can succeed for real underlying
-			// dynamic type
-			//
-			if (ignore_inferred_dynamic && HasDynamicTypeArgument (ttype.TypeArguments))
-				return true;
-
 			if (mc != null) {
 				mc.Module.Compiler.Report.SymbolRelatedToPreviousError (tparam);
 				if (atype.IsGenericParameter) {

ICSharpCode.NRefactory.CSharp/Parser/mcs/import.cs

@@ -90,7 +90,7 @@ namespace Mono.CSharp
 				if (cad.Count > 0) {
 					foreach (var ca in cad) {
 						var dt = ca.Constructor.DeclaringType;
-						if (dt.Name != "DynamicAttribute" && dt.Namespace != CompilerServicesNamespace)
+						if (dt.Name != "DynamicAttribute" || dt.Namespace != CompilerServicesNamespace)
 							continue;
 
 						if (ca.ConstructorArguments.Count == 0) {
@@ -390,18 +390,21 @@ namespace Mono.CSharp
 				if ((mod & Modifiers.OVERRIDE) != 0) {
 					bool is_real_override = false;
 					if (kind == MemberKind.Method && declaringType.BaseType != null) {
-						var filter = MemberFilter.Method (name, tparams != null ? tparams.Length : 0, parameters, null);
-						var candidate = MemberCache.FindMember (declaringType.BaseType, filter, BindingRestriction.None);
-
-						//
-						// For imported class method do additional validation to be sure that metadata
-						// override flag was correct
-						// 
-						// Difference between protected internal and protected is ok
-						//
-						const Modifiers conflict_mask = Modifiers.AccessibilityMask & ~Modifiers.INTERNAL;
-						if (candidate != null && (candidate.Modifiers & conflict_mask) == (mod & conflict_mask) && !candidate.IsStatic) {
-							is_real_override = true;
+						var btype = declaringType.BaseType;
+						if (IsOverrideMethodBaseTypeAccessible (btype)) {
+							var filter = MemberFilter.Method (name, tparams != null ? tparams.Length : 0, parameters, null);
+							var candidate = MemberCache.FindMember (btype, filter, BindingRestriction.None);
+
+							//
+							// For imported class method do additional validation to be sure that metadata
+							// override flag was correct
+							// 
+							// Difference between protected internal and protected is ok
+							//
+							const Modifiers conflict_mask = Modifiers.AccessibilityMask & ~Modifiers.INTERNAL;
+							if (candidate != null && (candidate.Modifiers & conflict_mask) == (mod & conflict_mask) && !candidate.IsStatic) {
+								is_real_override = true;
+							}
 						}
 					}
 
@@ -434,6 +437,30 @@ namespace Mono.CSharp
 			return ms;
 		}
 
+		bool IsOverrideMethodBaseTypeAccessible (TypeSpec baseType)
+		{
+			switch (baseType.Modifiers & Modifiers.AccessibilityMask) {
+			case Modifiers.PUBLIC:
+				return true;
+			case Modifiers.INTERNAL:
+				//
+				// Check whether imported method in base type is accessible from compiled
+				// context
+				//
+				return baseType.MemberDefinition.IsInternalAsPublic (module.DeclaringAssembly);
+			case Modifiers.PRIVATE:
+				return false;
+			default:
+				// protected
+				// protected internal
+				// 
+				// Method accessibility checks will be done later based on context
+				// where the method is called (CS0122 error will be reported for inaccessible)
+				//
+				return true;
+			}
+		}
+
 		//
 		// Imports System.Reflection parameters
 		//

ICSharpCode.NRefactory.CSharp/Parser/mcs/location.cs

@@ -52,13 +52,15 @@ namespace Mono.CSharp
 			}
 		}
 
+		static readonly byte[] MD5Algorith = { 96, 166, 110, 64, 207, 100, 130, 76, 182, 240, 66, 212, 129, 114, 167, 153 };
+
 		public readonly string Name;
 		public readonly string FullPathName;
 		public readonly int Index;
 		public bool AutoGenerated;
 
 		SourceFileEntry file;
-		byte[] guid, checksum;
+		byte[] algGuid, checksum;
 		List<LocationRegion> hidden_lines;
 
 		public SourceFile (string name, string path, int index)
@@ -68,15 +70,32 @@ namespace Mono.CSharp
 			this.FullPathName = path;
 		}
 
+		public byte[] Checksum {
+			get {
+				return checksum;
+			}
+		}
+
+		public bool HasChecksum {
+			get {
+				return checksum != null;
+			}
+		}
+
 		public SourceFileEntry SourceFileEntry {
 			get {
 				return file;
 			}
 		}
 
-		public void SetChecksum (byte[] guid, byte[] checksum)
+		public void SetChecksum (byte[] checksum)
 		{
-			this.guid = guid;
+			SetChecksum (MD5Algorith, checksum);
+		}
+
+		public void SetChecksum (byte[] algorithmGuid, byte[] checksum)
+		{
+			this.algGuid = algorithmGuid;
 			this.checksum = checksum;
 		}
 
@@ -85,13 +104,9 @@ namespace Mono.CSharp
 			if (hidden_lines != null)
 				hidden_lines.Sort ();
 
-			if (guid != null) {
-				file = new SourceFileEntry (symwriter, FullPathName, guid, checksum);
-			} else {
-				file = new SourceFileEntry (symwriter, FullPathName);
-				if (AutoGenerated)
-					file.SetAutoGenerated ();
-			}
+			file = new SourceFileEntry (symwriter, FullPathName, algGuid, checksum);
+			if (AutoGenerated)
+				file.SetAutoGenerated ();
 
 			return file;
 		}
@@ -177,7 +192,6 @@ namespace Mono.CSharp
 		const int max_column = column_mask;
 
 		static List<SourceFile> source_list;
-		static int current_source;
 		static Checkpoint [] checkpoints;
 		static int checkpoint_index;
 		
@@ -192,7 +206,6 @@ namespace Mono.CSharp
 		public static void Reset ()
 		{
 			source_list = new List<SourceFile> ();
-			current_source = 0;
 			checkpoint_index = 0;
 		}
 
@@ -220,13 +233,7 @@ namespace Mono.CSharp
 				checkpoints [0] = new Checkpoint (0, 0);
 		}
 
-		static public void Push (SourceFile file)
-		{
-			current_source = file != null ? file.Index : -1;
-			// File is always pushed before being changed.
-		}
-		
-		public Location (int row, int column)
+		public Location (SourceFile file, int row, int column)
 		{
 			if (row <= 0)
 				token = 0;
@@ -237,6 +244,9 @@ namespace Mono.CSharp
 				long target = -1;
 				long delta = 0;
 
+				// TODO: For eval only, need better handling of empty
+				int file_index = file == null ? 0 : file.Index;
+
 				// FIXME: This value is certainly wrong but what was the intension
 				int max = checkpoint_index < 10 ?
 					checkpoint_index : 10;
@@ -245,13 +255,13 @@ namespace Mono.CSharp
 					delta = row - offset;
 					if (delta >= 0 &&
 						delta < (1 << line_delta_bits) &&
-						checkpoints [checkpoint_index - i].File == current_source) {
+						checkpoints[checkpoint_index - i].File == file_index) {
 						target = checkpoint_index - i;
 						break;
 					}
 				}
 				if (target == -1) {
-					AddCheckpoint (current_source, row);
+					AddCheckpoint (file_index, row);
 					target = checkpoint_index;
 					delta = row % (1 << line_delta_bits);
 				}
@@ -269,7 +279,7 @@ namespace Mono.CSharp
 
 		public static Location operator - (Location loc, int columns)
 		{
-			return new Location (loc.Row, loc.Column - columns);
+			return new Location (loc.SourceFile, loc.Row, loc.Column - columns);
 		}
 
 		static void AddCheckpoint (int file, int row)

ICSharpCode.NRefactory.CSharp/Parser/mcs/membercache.cs

@@ -435,12 +435,15 @@ namespace Mono.CSharp {
 		// A special method to work with member lookup only. It returns a list of all members named @name
 		// starting from @container. It's very performance sensitive
 		//
-		public static IList<MemberSpec> FindMembers (TypeSpec container, string name, bool declaredOnly)
+		// declaredOnlyClass cannot be used interfaces. Manual filtering is required because names are
+		// compacted
+		//
+		public static IList<MemberSpec> FindMembers (TypeSpec container, string name, bool declaredOnlyClass)
 		{
 			IList<MemberSpec> applicable;
 
 			do {
-				if (container.MemberCache.member_hash.TryGetValue (name, out applicable) || declaredOnly)
+				if (container.MemberCache.member_hash.TryGetValue (name, out applicable) || declaredOnlyClass)
 					return applicable;
 
 				container = container.BaseType;

ICSharpCode.NRefactory.CSharp/Parser/mcs/method.cs

@@ -1213,6 +1213,9 @@ namespace Mono.CSharp {
 					block = (ToplevelBlock) block.ConvertToAsyncTask (this, Parent.PartialContainer, parameters, ReturnType, Location);
 					ModFlags |= Modifiers.DEBUGGER_HIDDEN;
 				}
+
+				if (Compiler.Settings.WriteMetadataOnly)
+					block = null;
 			}
 
 			if ((ModFlags & Modifiers.STATIC) == 0)
@@ -1301,10 +1304,18 @@ namespace Mono.CSharp {
 					}
 				}
 
-				base.Emit ();
-				
+				if (block != null && block.StateMachine != null) {
+					var psm = block.StateMachine is IteratorStorey ?
+						Module.PredefinedAttributes.IteratorStateMachine :
+						Module.PredefinedAttributes.AsyncStateMachine;
+					
+					psm.EmitAttribute (MethodBuilder, block.StateMachine);
+				}
+
 				if ((ModFlags & Modifiers.METHOD_EXTENSION) != 0)
 					Module.PredefinedAttributes.Extension.EmitAttribute (MethodBuilder);
+
+				base.Emit ();
 			} catch {
 				Console.WriteLine ("Internal compiler error at {0}: exception caught while emitting {1}",
 						   Location, MethodBuilder);
@@ -1617,10 +1628,15 @@ namespace Mono.CSharp {
 			
 			Parent.MemberCache.AddMember (spec);
 			
-			// It's here only to report an error
-			if (block != null && block.IsIterator) {
-				member_type = Compiler.BuiltinTypes.Void;
-				Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags);
+			if (block != null) {
+				// It's here only to report an error
+				if (block.IsIterator) {
+					member_type = Compiler.BuiltinTypes.Void;
+					Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags);
+				}
+
+				if (Compiler.Settings.WriteMetadataOnly)
+					block = null;
 			}
 
 			return true;
@@ -1656,14 +1672,14 @@ namespace Mono.CSharp {
 			BlockContext bc = new BlockContext (this, block, Compiler.BuiltinTypes.Void);
 			bc.Set (ResolveContext.Options.ConstructorScope);
 
-			//
-			// If we use a "this (...)" constructor initializer, then
-			// do not emit field initializers, they are initialized in the other constructor
-			//
-			if (!(Initializer is ConstructorThisInitializer))
-				Parent.PartialContainer.ResolveFieldInitializers (bc);
-
 			if (block != null) {
+				//
+				// If we use a "this (...)" constructor initializer, then
+				// do not emit field initializers, they are initialized in the other constructor
+				//
+				if (!(Initializer is ConstructorThisInitializer))
+					Parent.PartialContainer.ResolveFieldInitializers (bc);
+
 				if (!IsStatic) {
 					if (Initializer == null) {
 						if (Parent.PartialContainer.Kind == MemberKind.Struct) {
@@ -2155,6 +2171,16 @@ namespace Mono.CSharp {
 			return true;
 		}
 
+		public override bool Define ()
+		{
+			base.Define ();
+
+			if (Compiler.Settings.WriteMetadataOnly)
+				block = null;
+
+			return true;
+		}
+
 		public override void Emit()
 		{
 			var base_type = Parent.PartialContainer.BaseType;
@@ -2518,13 +2544,18 @@ namespace Mono.CSharp {
 			if (!base.Define ())
 				return false;
 
-			if (block != null && block.IsIterator) {
-				//
-				// Current method is turned into automatically generated
-				// wrapper which creates an instance of iterator
-				//
-				Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags);
-				ModFlags |= Modifiers.DEBUGGER_HIDDEN;
+			if (block != null) {
+				if (block.IsIterator) {
+					//
+					// Current method is turned into automatically generated
+					// wrapper which creates an instance of iterator
+					//
+					Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags);
+					ModFlags |= Modifiers.DEBUGGER_HIDDEN;
+				}
+
+				if (Compiler.Settings.WriteMetadataOnly)
+					block = null;
 			}
 
 			// imlicit and explicit operator of same types are not allowed

ICSharpCode.NRefactory.CSharp/Parser/mcs/module.cs

@@ -429,7 +429,7 @@ namespace Mono.CSharp
 
 			base.EmitContainer ();
 
-			if (Compiler.Report.Errors == 0)
+			if (Compiler.Report.Errors == 0 && !Compiler.Settings.WriteMetadataOnly)
 				VerifyMembers ();
 
 			if (anonymous_types != null) {

ICSharpCode.NRefactory.CSharp/Parser/mcs/namespace.cs

@@ -41,6 +41,46 @@ namespace Mono.CSharp {
 			report.Error (1681, loc, "The global extern alias cannot be redefined");
 		}
 
+		//
+		// For better error reporting where we try to guess missing using directive
+		//
+		public List<string> FindTypeNamespaces (IMemberContext ctx, string name, int arity)
+		{
+			List<string> res = null;
+
+			foreach (var ns in all_namespaces) {
+				var type = ns.Value.LookupType (ctx, name, arity, LookupMode.Normal, Location.Null);
+				if (type != null) {
+					if (res == null)
+						res = new List<string> ();
+
+					res.Add (ns.Key);
+				}
+			}
+
+			return res;
+		}
+
+		//
+		// For better error reporting where compiler tries to guess missing using directive
+		//
+		public List<string> FindExtensionMethodNamespaces (IMemberContext ctx, TypeSpec extensionType, string name, int arity)
+		{
+			List<string> res = null;
+
+			foreach (var ns in all_namespaces) {
+				var methods = ns.Value.LookupExtensionMethod (ctx, extensionType, name, arity);
+				if (methods != null) {
+					if (res == null)
+						res = new List<string> ();
+
+					res.Add (ns.Key);
+				}
+			}
+
+			return res;
+		}
+
 		public void RegisterNamespace (Namespace child)
 		{
 			if (child != this)
@@ -181,14 +221,51 @@ namespace Mono.CSharp {
 				return;
 			}
 
+			string assembly = null;
+			string possible_name = fullname + "." + name;
+
+			// Only assembly unique name should be added
+			switch (possible_name) {
+			case "System.Drawing":
+			case "System.Web.Services":
+			case "System.Web":
+			case "System.Data":
+			case "System.Configuration":
+			case "System.Data.Services":
+			case "System.DirectoryServices":
+			case "System.Json":
+			case "System.Net.Http":
+			case "System.Numerics":
+			case "System.Runtime.Caching":
+			case "System.ServiceModel":
+			case "System.Transactions":
+			case "System.Web.Routing":
+			case "System.Xml.Linq":
+			case "System.Xml":
+				assembly = possible_name;
+				break;
+
+			case "System.Linq":
+			case "System.Linq.Expressions":
+				assembly = "System.Core";
+				break;
+
+			case "System.Windows.Forms":
+			case "System.Windows.Forms.Layout":
+				assembly = "System.Windows.Name";
+				break;
+			}
+
+			assembly = assembly == null ? "an" : "`" + assembly + "'";
+
 			if (this is GlobalRootNamespace) {
 				ctx.Module.Compiler.Report.Error (400, loc,
-					"The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
-					name);
+					"The type or namespace name `{0}' could not be found in the global namespace. Are you missing {1} assembly reference?",
+					name, assembly);
 			} else {
 				ctx.Module.Compiler.Report.Error (234, loc,
-					"The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
-					name, GetSignatureForError ());
+					"The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing {2} assembly reference?",
+					name, GetSignatureForError (), assembly);
 			}
 		}
 
@@ -209,10 +286,16 @@ namespace Mono.CSharp {
 				ns_parent = this;
 			}
 
+			return ns_parent.TryAddNamespace (name.Basename);
+		}
+
+		Namespace TryAddNamespace (string name)
+		{
 			Namespace ns;
-			if (!ns_parent.namespaces.TryGetValue (name.Basename, out ns)) {
-				ns = new Namespace (ns_parent, name.Basename);
-				ns_parent.namespaces.Add (name.Basename, ns);
+
+			if (!namespaces.TryGetValue (name, out ns)) {
+				ns = new Namespace (this, name);
+				namespaces.Add (name, ns);
 			}
 
 			return ns;
@@ -1110,44 +1193,6 @@ namespace Mono.CSharp {
 			return match;
 		}
 
-		static void MsgtryRef (string s)
-		{
-			Console.WriteLine ("    Try using -r:" + s);
-		}
-
-		static void MsgtryPkg (string s)
-		{
-			Console.WriteLine ("    Try using -pkg:" + s);
-		}
-
-		public static void Error_NamespaceNotFound (Location loc, string name, Report Report)
-		{
-			Report.Error (246, loc, "The type or namespace name `{0}' could not be found. Are you missing a using directive or an assembly reference?",
-				name);
-
-			switch (name) {
-			case "Gtk": case "GtkSharp":
-				MsgtryPkg ("gtk-sharp-2.0");
-				break;
-
-			case "Gdk": case "GdkSharp":
-				MsgtryPkg ("gdk-sharp-2.0");
-				break;
-
-			case "Glade": case "GladeSharp":
-				MsgtryPkg ("glade-sharp-2.0");
-				break;
-
-			case "System.Drawing":
-			case "System.Web.Services":
-			case "System.Web":
-			case "System.Data":
-			case "System.Windows.Forms":
-				MsgtryRef (name);
-				break;
-			}
-		}
-
 		protected override void DefineNamespace ()
 		{
 			if (namespace_using_table == null)

ICSharpCode.NRefactory.CSharp/Parser/mcs/nullable.cs

@@ -539,8 +539,8 @@ namespace Mono.CSharp.Nullable
 		Expression user_operator;
 		MethodSpec wrap_ctor;
 
-		public LiftedBinaryOperator (Binary.Operator op, Expression left, Expression right, Location loc)
-			: base (op, left, right, loc)
+		public LiftedBinaryOperator (Binary.Operator op, Expression left, Expression right)
+			: base (op, left, right)
 		{
 		}
 
@@ -583,7 +583,7 @@ namespace Mono.CSharp.Nullable
 			Constant c = new BoolConstant (ec.BuiltinTypes, Oper == Operator.Inequality, loc);
 
 			if ((Oper & Operator.EqualityMask) != 0) {
-				ec.Report.Warning (472, 2, loc, "The result of comparing value type `{0}' with null is `{1}'",
+				ec.Report.Warning (472, 2, loc, "The result of comparing value type `{0}' with null is always `{1}'",
 					TypeManager.CSharpName (expr.Type), c.GetValueAsLiteral ());
 			} else {
 				ec.Report.Warning (464, 2, loc, "The result of comparing type `{0}' with null is always `{1}'",
@@ -1000,12 +1000,12 @@ namespace Mono.CSharp.Nullable
 	{
 		Expression left, right;
 		Unwrap unwrap;
-		
-		public NullCoalescingOperator (Expression left, Expression right, Location loc)
+
+		public NullCoalescingOperator (Expression left, Expression right)
 		{
 			this.left = left;
 			this.right = right;
-			this.loc = loc;
+			this.loc = left.Location;
 		}
 
 		public Expression LeftExpression {

ICSharpCode.NRefactory.CSharp/Parser/mcs/outline.cs

@@ -142,7 +142,6 @@ public class Outline {
 		first = true;
 		
 		foreach (ConstructorInfo ci in t.GetConstructors (DefaultFlags)) {
-			
 			if (! ShowMember (ci))
 				continue;
 			
@@ -150,6 +149,7 @@ public class Outline {
 				o.WriteLine ();
 			first = false;
 			
+			OutlineMemberAttribute (ci);
 			OutlineConstructor (ci);
 			
 			o.WriteLine ();
@@ -169,7 +169,8 @@ public class Outline {
 			if (first)
 				o.WriteLine ();
 			first = false;
-			
+
+			OutlineMemberAttribute (m);
 			OutlineMethod (m);
 			
 			o.WriteLine ();
@@ -191,6 +192,7 @@ public class Outline {
 				o.WriteLine ();
 			first = false;
 			
+			OutlineMemberAttribute (m);
 			OutlineOperator (m);
 			
 			o.WriteLine ();
@@ -208,6 +210,7 @@ public class Outline {
 				o.WriteLine ();
 			first = false;
 			
+			OutlineMemberAttribute (pi);
 			OutlineProperty (pi);
 			
 			o.WriteLine ();
@@ -224,6 +227,7 @@ public class Outline {
 				o.WriteLine ();
 			first = false;
 			
+			OutlineMemberAttribute (fi);
 			OutlineField (fi);
 			
 			o.WriteLine ();
@@ -240,6 +244,7 @@ public class Outline {
 				o.WriteLine ();
 			first = false;
 			
+			OutlineMemberAttribute (ei);
 			OutlineEvent (ei);
 			
 			o.WriteLine ();
@@ -286,6 +291,15 @@ public class Outline {
 			o.WriteLine ("[Obsolete]");
 	}
 
+	void OutlineMemberAttribute (MemberInfo mi)
+	{
+		if (!mi.IsDefined (typeof (System.ObsoleteAttribute), false))
+			return;
+		var oa = mi.GetCustomAttributes (typeof (System.ObsoleteAttribute), false) [0] as ObsoleteAttribute;
+		var msg = oa.Message;
+		o.WriteLine ("[Obsolete{0}]", msg == null || msg == "" ? "" : string.Format ("(\"{0}\")", msg));
+	}
+	
 	void OutlineEvent (EventInfo ei)
 	{
 		MethodBase accessor = ei.GetAddMethod (true);

ICSharpCode.NRefactory.CSharp/Parser/mcs/property.cs

@@ -362,8 +362,13 @@ namespace Mono.CSharp
 				CheckAbstractAndExtern (block != null);
 				CheckProtectedModifier ();
 
-				if (block != null && block.IsIterator)
-					Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags);
+				if (block != null) {
+					if (block.IsIterator)
+						Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags);
+
+					if (Compiler.Settings.WriteMetadataOnly)
+						block = null;
+				}
 
 				return null;
 			}
@@ -906,7 +911,7 @@ namespace Mono.CSharp
 
 			public override void Emit (TypeDefinition parent)
 			{
-				if ((method.ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) == 0) {
+				if ((method.ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) == 0 && !Compiler.Settings.WriteMetadataOnly) {
 					block = new ToplevelBlock (Compiler, ParameterInfo, Location) {
 						IsCompilerGenerated = true
 					};
@@ -938,11 +943,10 @@ namespace Mono.CSharp
 
 				var cond = new BooleanExpression (new Binary (Binary.Operator.Inequality,
 					new Cast (new TypeExpression (Module.Compiler.BuiltinTypes.Object, Location), new LocalVariableReference (obj1, Location), Location),
-					new Cast (new TypeExpression (Module.Compiler.BuiltinTypes.Object, Location), new LocalVariableReference (obj2, Location), Location),
-					Location));
+					new Cast (new TypeExpression (Module.Compiler.BuiltinTypes.Object, Location), new LocalVariableReference (obj2, Location), Location)));
 
 				var body = new ExplicitBlock (block, Location, Location);
-				block.AddStatement (new Do (body, cond, Location));
+				block.AddStatement (new Do (body, cond, Location, Location));
 
 				body.AddStatement (new StatementExpression (
 					new SimpleAssign (new LocalVariableReference (obj2, Location), new LocalVariableReference (obj1, Location))));
@@ -1194,6 +1198,9 @@ namespace Mono.CSharp
 				if (!method_data.Define (parent.PartialContainer, method.GetFullName (MemberName)))
 					return null;
 
+				if (Compiler.Settings.WriteMetadataOnly)
+					block = null;
+
 				MethodBuilder mb = method_data.MethodBuilder;
 
 				Spec = new MethodSpec (MemberKind.Method, parent.PartialContainer.Definition, this, ReturnType, mb, ParameterInfo, method.ModFlags);

ICSharpCode.NRefactory.CSharp/Parser/mcs/report.cs

@@ -49,7 +49,7 @@ namespace Mono.CSharp {
 			809, 824,
 			1030, 1058, 1060, 1066,
 			1522, 1570, 1571, 1572, 1573, 1574, 1580, 1581, 1584, 1587, 1589, 1590, 1591, 1592,
-			1607, 1616, 1633, 1634, 1635, 1685, 1690, 1691, 1692, 1695, 1696, 1699,
+			1607, 1616, 1633, 1634, 1635, 1685, 1690, 1691, 1692, 1695, 1696, 1697, 1699,
 			1700, 1701, 1702, 1709, 1711, 1717, 1718, 1720, 1735,
 			1901, 1956, 1981, 1998,
 			2002, 2023, 2029,

ICSharpCode.NRefactory.CSharp/Parser/mcs/settings.cs

@@ -159,6 +159,8 @@ namespace Mono.CSharp {
 
 		public RuntimeVersion StdLibRuntimeVersion;
 
+		public bool WriteMetadataOnly;
+
 		readonly List<string> conditional_symbols;
 
 		readonly List<SourceFile> source_files;
@@ -180,10 +182,8 @@ namespace Mono.CSharp {
 			StdLibRuntimeVersion = RuntimeVersion.v4;
 			WarningLevel = 4;
 
-			if (Environment.OSVersion.Platform == PlatformID.Win32NT)
-				TabSize = 4;
-			else
-				TabSize = 8;
+			// Default to 1 or mdb files would be platform speficic
+			TabSize = 1;
 
 			AssemblyReferences = new List<string> ();
 			AssemblyReferencesAliases = new List<Tuple<string, string>> ();
@@ -224,11 +224,7 @@ namespace Mono.CSharp {
 				return source_files;
 			}
 		}
-		
-		public IList<string> ConditionalSymbols {
-			get { return conditional_symbols; }
-		}
-		
+
 		#endregion
 
 		public void AddConditionalSymbol (string symbol)
@@ -674,8 +670,9 @@ namespace Mono.CSharp {
 		{
 			output.WriteLine (
 				"Other flags in the compiler\n" +
-				"   --fatal[=COUNT]    Makes errors after COUNT fatal\n" +
+				"   --fatal[=COUNT]    Makes error after COUNT fatal\n" +
 				"   --lint             Enhanced warnings\n" +
+				"   --metadata-only    Produced assembly will contain metadata only\n" +
 				"   --parse            Only parses the source file\n" +
 				"   --runtime:VERSION  Sets mscorlib.dll metadata version: v1, v2, v4\n" +
 				"   --stacktrace       Shows stack trace at error location\n" +
@@ -937,7 +934,7 @@ namespace Mono.CSharp {
 				return ParseResult.Success;
 
 			case "/debug":
-				if (value == "full" || value == "pdbonly" || idx < 0) {
+				if (value.Equals ("full", StringComparison.OrdinalIgnoreCase) || value.Equals ("pdbonly", StringComparison.OrdinalIgnoreCase) || idx < 0) {
 					settings.GenerateDebugInfo = true;
 					return ParseResult.Success;
 				}
@@ -1429,6 +1426,10 @@ namespace Mono.CSharp {
 				settings.LoadDefaultReferences = false;
 				return ParseResult.Success;
 
+			case "--metadata-only":
+				settings.WriteMetadataOnly = true;
+				return ParseResult.Success;
+
 			default:
 				if (arg.StartsWith ("--fatal", StringComparison.Ordinal)){
 					int fatal = 1;

ICSharpCode.NRefactory.CSharp/Parser/mcs/statement.cs

@@ -281,11 +281,16 @@ namespace Mono.CSharp {
 		public Expression expr;
 		public Statement  EmbeddedStatement;
 
-		public Do (Statement statement, BooleanExpression bool_expr, Location l)
+		public Do (Statement statement, BooleanExpression bool_expr, Location doLocation, Location whileLocation)
 		{
 			expr = bool_expr;
 			EmbeddedStatement = statement;
-			loc = l;
+			loc = doLocation;
+			WhileLocation = whileLocation;
+		}
+
+		public Location WhileLocation {
+			get; private set;
 		}
 
 		public override bool Resolve (BlockContext ec)
@@ -332,7 +337,7 @@ namespace Mono.CSharp {
 			ec.MarkLabel (ec.LoopBegin);
 
 			// Mark start of while condition
-			ec.Mark (expr.Location);
+			ec.Mark (WhileLocation);
 
 			//
 			// Dead code elimination
@@ -461,7 +466,7 @@ namespace Mono.CSharp {
 			
 				ec.MarkLabel (ec.LoopBegin);
 
-				ec.Mark (expr.Location);
+				ec.Mark (loc);
 				expr.EmitBranchable (ec, while_loop, true);
 				
 				ec.MarkLabel (ec.LoopEnd);
@@ -878,7 +883,6 @@ namespace Mono.CSharp {
 							return true;
 						}
 
-						// TODO: Better error message
 						if (async_type.Kind == MemberKind.Void) {
 							ec.Report.Error (127, loc,
 								"`{0}': A return keyword must not be followed by any expression when method returns void",
@@ -909,6 +913,15 @@ namespace Mono.CSharp {
 						}
 					}
 				} else {
+					// Same error code as .NET but better error message
+					if (block_return_type.Kind == MemberKind.Void) {
+						ec.Report.Error (127, loc,
+							"`{0}': A return keyword must not be followed by any expression when delegate returns void",
+							am.GetSignatureForError ());
+
+						return false;
+					}
+
 					var l = am as AnonymousMethodBody;
 					if (l != null && l.ReturnTypeInference != null && expr != null) {
 						l.ReturnTypeInference.AddCommonTypeBound (expr.Type);
@@ -1620,8 +1633,10 @@ namespace Mono.CSharp {
 			if (declarators != null) {
 				foreach (var d in declarators) {
 					d.Variable.CreateBuilder (ec);
-					if (d.Initializer != null)
+					if (d.Initializer != null) {
+						ec.Mark (d.Variable.Location);
 						((ExpressionStatement) d.Initializer).EmitStatement (ec);
+					}
 				}
 			}
 		}
@@ -4236,10 +4251,10 @@ namespace Mono.CSharp {
 
 				Expression cond = null;
 				for (int ci = 0; ci < s.Labels.Count; ++ci) {
-					var e = new Binary (Binary.Operator.Equality, value, s.Labels[ci].Converted, loc);
+					var e = new Binary (Binary.Operator.Equality, value, s.Labels[ci].Converted);
 
 					if (ci > 0) {
-						cond = new Binary (Binary.Operator.LogicalOr, cond, e, loc);
+						cond = new Binary (Binary.Operator.LogicalOr, cond, e);
 					} else {
 						cond = e;
 					}
@@ -5130,8 +5145,8 @@ namespace Mono.CSharp {
 					// fixed (T* e_ptr = (e == null || e.Length == 0) ? null : converted [0])
 					//
 					converted = new Conditional (new BooleanExpression (new Binary (Binary.Operator.LogicalOr,
-						new Binary (Binary.Operator.Equality, initializer, new NullLiteral (loc), loc),
-						new Binary (Binary.Operator.Equality, new MemberAccess (initializer, "Length"), new IntConstant (bc.BuiltinTypes, 0, loc), loc), loc)),
+						new Binary (Binary.Operator.Equality, initializer, new NullLiteral (loc)),
+						new Binary (Binary.Operator.Equality, new MemberAccess (initializer, "Length"), new IntConstant (bc.BuiltinTypes, 0, loc)))),
 							new NullLiteral (loc),
 							converted, loc);
 
@@ -5697,7 +5712,7 @@ namespace Mono.CSharp {
 
 				// Add conditional call when disposing possible null variable
 				if (!type.IsStruct || type.IsNullableType)
-					dispose = new If (new Binary (Binary.Operator.Inequality, lvr, new NullLiteral (loc), loc), dispose, dispose.loc);
+					dispose = new If (new Binary (Binary.Operator.Inequality, lvr, new NullLiteral (loc)), dispose, dispose.loc);
 
 				return dispose;
 			}
@@ -5711,7 +5726,7 @@ namespace Mono.CSharp {
 			{
 				for (int i = declarators.Count - 1; i >= 0; --i) {
 					var d = declarators [i];
-					var vd = new VariableDeclaration (d.Variable, type_expr.Location);
+					var vd = new VariableDeclaration (d.Variable, d.Variable.Location);
 					vd.Initializer = d.Initializer;
 					vd.IsNested = true;
 					vd.dispose_call = CreateDisposeCall (bc, d.Variable);
@@ -5947,7 +5962,7 @@ namespace Mono.CSharp {
 				if (variable_ref == null)
 					return false;
 
-				for_each.body.AddScopeStatement (new StatementExpression (new CompilerAssign (variable_ref, access, Location.Null), for_each.variable.Location));
+				for_each.body.AddScopeStatement (new StatementExpression (new CompilerAssign (variable_ref, access, Location.Null), for_each.type.Location));
 
 				bool ok = true;
 
@@ -6043,7 +6058,7 @@ namespace Mono.CSharp {
 					var idisaposable_test = new Binary (Binary.Operator.Inequality, new CompilerAssign (
 						dispose_variable.CreateReferenceExpression (bc, loc),
 						new As (lv.CreateReferenceExpression (bc, loc), new TypeExpression (dispose_variable.Type, loc), loc),
-						loc), new NullLiteral (loc), loc);
+						loc), new NullLiteral (loc));
 
 					var m = bc.Module.PredefinedMembers.IDisposableDispose.Resolve (loc);
 
@@ -6258,7 +6273,7 @@ namespace Mono.CSharp {
 				if (variable_ref == null)
 					return false;
 
-				for_each.body.AddScopeStatement (new StatementExpression (new CompilerAssign (variable_ref, current_pe, Location.Null), variable.Location));
+				for_each.body.AddScopeStatement (new StatementExpression (new CompilerAssign (variable_ref, current_pe, Location.Null), for_each.type.Location));
 
 				var init = new Invocation (get_enumerator_mg, null);
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/support.cs

@@ -137,21 +137,23 @@ namespace Mono.CSharp {
 	/// </summary>
 	public class SeekableStreamReader : IDisposable
 	{
+		public const int DefaultReadAheadSize = 2048;
+
 		StreamReader reader;
 		Stream stream;
 
-		static char[] buffer;
+		char[] buffer;
 		int read_ahead_length;	// the length of read buffer
 		int buffer_start;       // in chars
 		int char_count;         // count of filled characters in buffer[]
 		int pos;                // index into buffer[]
 
-		public SeekableStreamReader (Stream stream, Encoding encoding)
+		public SeekableStreamReader (Stream stream, Encoding encoding, char[] sharedBuffer = null)
 		{
 			this.stream = stream;
+			this.buffer = sharedBuffer;
 
-			const int default_read_ahead = 2048;
-			InitializeStream (default_read_ahead);
+			InitializeStream (DefaultReadAheadSize);
 			reader = new StreamReader (stream, encoding, true);
 		}
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/typemanager.cs

@@ -144,7 +144,7 @@ namespace Mono.CSharp
 		{
 			var ctx = module.Compiler;
 			foreach (var p in types) {
-				var found = PredefinedType.Resolve (module, p.Kind, p.Namespace, p.Name, p.Arity);
+				var found = PredefinedType.Resolve (module, p.Kind, p.Namespace, p.Name, p.Arity, true, true);
 				if (found == null || found == p)
 					continue;
 
@@ -340,6 +340,7 @@ namespace Mono.CSharp
 		public readonly PredefinedMember<MethodSpec> AsyncVoidMethodBuilderSetStateMachine;
 		public readonly PredefinedMember<MethodSpec> AsyncVoidMethodBuilderOnCompleted;
 		public readonly PredefinedMember<MethodSpec> AsyncVoidMethodBuilderOnCompletedUnsafe;
+		public readonly PredefinedMember<MethodSpec> AsyncStateMachineAttributeCtor;
 		public readonly PredefinedMember<MethodSpec> DebuggerBrowsableAttributeCtor;
 		public readonly PredefinedMember<MethodSpec> DecimalCtor;
 		public readonly PredefinedMember<MethodSpec> DecimalCtorInt;
@@ -357,6 +358,7 @@ namespace Mono.CSharp
 		public readonly PredefinedMember<MethodSpec> IEnumerableGetEnumerator;
 		public readonly PredefinedMember<MethodSpec> InterlockedCompareExchange;
 		public readonly PredefinedMember<MethodSpec> InterlockedCompareExchange_T;
+		public readonly PredefinedMember<MethodSpec> IteratorStateMachineAttributeCtor;
 		public readonly PredefinedMember<MethodSpec> FixedBufferAttributeCtor;
 		public readonly PredefinedMember<MethodSpec> MethodInfoGetMethodFromHandle;
 		public readonly PredefinedMember<MethodSpec> MethodInfoGetMethodFromHandle2;
@@ -549,6 +551,10 @@ namespace Mono.CSharp
 							}, false),
 					btypes.Void));
 
+			AsyncStateMachineAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.AsyncStateMachine,
+				MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (
+					btypes.Type)));
+
 			DebuggerBrowsableAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.DebuggerBrowsable,
 				MemberFilter.Constructor (null));
 
@@ -625,6 +631,10 @@ namespace Mono.CSharp
 							}, false),
 					null));
 
+			IteratorStateMachineAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.IteratorStateMachine,
+				MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (
+					btypes.Type)));
+
 			MethodInfoGetMethodFromHandle = new PredefinedMember<MethodSpec> (module, types.MethodBase,
 				"GetMethodFromHandle", MemberKind.Method, types.RuntimeMethodHandle);
 
@@ -748,7 +758,7 @@ namespace Mono.CSharp
 			if (type != null)
 				return true;
 
-			type = Resolve (module, kind, ns, name, arity, false);
+			type = Resolve (module, kind, ns, name, arity, false, false);
 			return type != null;
 		}
 
@@ -757,17 +767,21 @@ namespace Mono.CSharp
 			return ns + "." + name;
 		}
 
-		public static TypeSpec Resolve (ModuleContainer module, MemberKind kind, string ns, string name, int arity)
+		public static TypeSpec Resolve (ModuleContainer module, MemberKind kind, string ns, string name, int arity, bool required, bool reportErrors)
 		{
-			return Resolve (module, kind, ns, name, arity, true);
-		}
+			//
+			// Cannot call it with true because it could create non-existent namespaces for
+			// predefined types. It's set to true only for build-in types which all must
+			// exist therefore it does not matter, for predefined types we don't want to create
+			// fake namespaces when type is optional and does not exist (e.g. System.Linq).
+			//
+			Namespace type_ns = module.GlobalRootNamespace.GetNamespace (ns, required);
+			IList<TypeSpec> found = null;
+			if (type_ns != null)
+				found = type_ns.GetAllTypes (name);
 
-		public static TypeSpec Resolve (ModuleContainer module, MemberKind kind, string ns, string name, int arity, bool reportErrors)
-		{
-			Namespace type_ns = module.GlobalRootNamespace.GetNamespace (ns, true);
-			var found = type_ns.GetAllTypes (name);
 			if (found == null) {
-				if (reportErrors)
+				if (reportErrors )
 					module.Compiler.Report.Error (518, "The predefined type `{0}.{1}' is not defined or imported", ns, name);
 
 				return null;
@@ -837,13 +851,13 @@ namespace Mono.CSharp
 		public TypeSpec Resolve ()
 		{
 			if (type == null)
-				type = Resolve (module, kind, ns, name, arity);
+				type = Resolve (module, kind, ns, name, arity, false, true);
 
 			return type;
 		}
 	}
 
-	class PredefinedMember<T> where T : MemberSpec
+	public class PredefinedMember<T> where T : MemberSpec
 	{
 		readonly ModuleContainer module;
 		T member;