Merge pull request #409 from Alkarex/patch-1

[mono.git] / mcs / mcs / context.cs

diff --git a/mcs/mcs/context.cs b/mcs/mcs/context.cs
index 4a2318c2b5db4e69ff64216be2f98166f3a0d51a..c06c1c478a8e849a4c59fb1bcc777f76c1ffa382 100644 (file)
--- a/mcs/mcs/context.cs
+++ b/mcs/mcs/context.cs
@@ -13,6 +13,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Security.Cryptography;
 
 namespace Mono.CSharp
 {
@@ -94,6 +95,18 @@ namespace Mono.CSharp
 
                        if (rc.HasSet (ResolveContext.Options.CheckedScope))
                                flags |= ResolveContext.Options.CheckedScope;
+
+                       if (rc.IsInProbingMode)
+                               flags |= ResolveContext.Options.ProbingMode;
+
+                       if (rc.HasSet (ResolveContext.Options.FieldInitializerScope))
+                               flags |= ResolveContext.Options.FieldInitializerScope;
+
+                       if (rc.HasSet (ResolveContext.Options.ExpressionTreeConversion))
+                               flags |= ResolveContext.Options.ExpressionTreeConversion;
+
+                       if (rc.HasSet (ResolveContext.Options.BaseInitializer))
+                               flags |= ResolveContext.Options.BaseInitializer;
                }
 
                public override FlowBranching CurrentBranching {
@@ -104,6 +117,24 @@ namespace Mono.CSharp
                        get { return return_type; }
                }
 
+               public bool IsUnreachable {
+                       get {
+                               return HasSet (Options.UnreachableScope);
+                       }
+                       set {
+                               flags = value ? flags | Options.UnreachableScope : flags & ~Options.UnreachableScope;
+                       }
+               }
+
+               public bool UnreachableReported {
+                       get {
+                               return HasSet (Options.UnreachableReported);
+                       }
+                       set {
+                               flags = value ? flags | Options.UnreachableReported : flags & ~Options.UnreachableScope;
+                       }
+               }
+
                // <summary>
                //   Starts a new code branching.  This inherits the state of all local
                //   variables and parameters from the current branching.
@@ -256,6 +287,10 @@ namespace Mono.CSharp
 
                        LockScope = 1 << 13,
 
+                       UnreachableScope = 1 << 14,
+
+                       UnreachableReported = 1 << 15,
+
                        /// <summary>
                        ///   Whether control flow analysis is enabled
                        /// </summary>
@@ -474,14 +509,14 @@ namespace Mono.CSharp
                        // or it's a parameter
                        //
                        if (CurrentAnonymousMethod.IsIterator)
-                               return local.IsParameter || CurrentBlock.Explicit.HasYield;
+                               return local.IsParameter || local.Block.Explicit.HasYield;
 
                        //
                        // Capture only if this or any of child blocks contain await
                        // or it's a parameter
                        //
                        if (CurrentAnonymousMethod is AsyncInitializer)
-                               return CurrentBlock.Explicit.HasAwait;
+                               return local.IsParameter || local.Block.Explicit.HasAwait || CurrentBlock.Explicit.HasAwait;
 
                        return local.Block.ParametersBlock != CurrentBlock.ParametersBlock.Original;
                }
@@ -730,4 +765,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 ());
+               }
+       }
 }