Merge sharpen to master

runtime/CSharp/Antlr4.Runtime/AntlrFileStream.cs

@@ -3,6 +3,7 @@
 
 #if !PORTABLE
 
+using Antlr4.Runtime.Misc;
 using Antlr4.Runtime.Sharpen;
 using Encoding = System.Text.Encoding;
 using File = System.IO.File;
@@ -24,20 +25,20 @@ public class AntlrFileStream : AntlrInputStream
         protected internal string fileName;
 
         /// <exception cref="System.IO.IOException"/>
-        public AntlrFileStream(string fileName)
+        public AntlrFileStream([NotNull] string fileName)
             : this(fileName, null)
         {
         }
 
         /// <exception cref="System.IO.IOException"/>
-        public AntlrFileStream(string fileName, Encoding encoding)
+        public AntlrFileStream([NotNull] string fileName, Encoding encoding)
         {
             this.fileName = fileName;
             Load(fileName, encoding);
         }
 
         /// <exception cref="System.IO.IOException"/>
-        public virtual void Load(string fileName, Encoding encoding)
+        public virtual void Load([NotNull] string fileName, [NotNull] Encoding encoding)
         {
             if (fileName == null)
             {

runtime/CSharp/Antlr4.Runtime/Atn/ATN.cs

@@ -79,7 +79,7 @@ public class ATN
         protected internal readonly ConcurrentDictionary<int, int> LL1Table = new ConcurrentDictionary<int, int>();
 
         /// <summary>Used for runtime deserialization of ATNs from strings</summary>
-        public ATN(ATNType grammarType, int maxTokenType)
+        public ATN([NotNull] ATNType grammarType, int maxTokenType)
         {
             this.grammarType = grammarType;
             this.maxTokenType = maxTokenType;
@@ -148,7 +148,7 @@ public DFA[] DecisionToDfa
         /// 's rule.
         /// </summary>
         [return: NotNull]
-        public virtual IntervalSet NextTokens(ATNState s, PredictionContext ctx)
+        public virtual IntervalSet NextTokens(ATNState s, [NotNull] PredictionContext ctx)
         {
             Args.NotNull("ctx", ctx);
             LL1Analyzer anal = new LL1Analyzer(this);
@@ -166,7 +166,7 @@ public virtual IntervalSet NextTokens(ATNState s, PredictionContext ctx)
         /// rule.
         /// </summary>
         [return: NotNull]
-        public virtual IntervalSet NextTokens(ATNState s)
+        public virtual IntervalSet NextTokens([NotNull] ATNState s)
         {
             if (s.nextTokenWithinRule != null)
             {
@@ -177,7 +177,7 @@ public virtual IntervalSet NextTokens(ATNState s)
             return s.nextTokenWithinRule;
         }
 
-        public virtual void AddState(ATNState state)
+        public virtual void AddState([Nullable] ATNState state)
         {
             if (state != null)
             {
@@ -187,13 +187,13 @@ public virtual void AddState(ATNState state)
             states.Add(state);
         }
 
-        public virtual void RemoveState(ATNState state)
+        public virtual void RemoveState([NotNull] ATNState state)
         {
             states[state.stateNumber] = null;
         }
 
         // just free mem, don't shift states in list
-        public virtual void DefineMode(string name, TokensStartState s)
+        public virtual void DefineMode([NotNull] string name, [NotNull] TokensStartState s)
         {
             modeNameToStartState[name] = s;
             modeToStartState.Add(s);
@@ -202,7 +202,7 @@ public virtual void DefineMode(string name, TokensStartState s)
             DefineDecisionState(s);
         }
 
-        public virtual int DefineDecisionState(DecisionState s)
+        public virtual int DefineDecisionState([NotNull] DecisionState s)
         {
             decisionToState.Add(s);
             s.decision = decisionToState.Count - 1;
@@ -275,7 +275,7 @@ public virtual int NumberOfDecisions
         /// <paramref name="stateNumber"/>
         /// </exception>
         [return: NotNull]
-        public virtual IntervalSet GetExpectedTokens(int stateNumber, RuleContext context)
+        public virtual IntervalSet GetExpectedTokens(int stateNumber, [Nullable] RuleContext context)
         {
             if (stateNumber < 0 || stateNumber >= states.Count)
             {

runtime/CSharp/Antlr4.Runtime/Atn/ATNConfig.cs

@@ -58,32 +58,32 @@ public class ATNConfig
         [NotNull]
         private PredictionContext context;
 
-        protected internal ATNConfig(ATNState state, int alt, PredictionContext context)
+        protected internal ATNConfig([NotNull] ATNState state, int alt, [NotNull] PredictionContext context)
         {
             System.Diagnostics.Debug.Assert((alt & unchecked((int)(0xFFFFFF))) == alt);
             this.state = state;
             this.altAndOuterContextDepth = alt;
             this.context = context;
         }
 
-        protected internal ATNConfig(Antlr4.Runtime.Atn.ATNConfig c, ATNState state, PredictionContext context)
+        protected internal ATNConfig([NotNull] Antlr4.Runtime.Atn.ATNConfig c, [NotNull] ATNState state, [NotNull] PredictionContext context)
         {
             this.state = state;
             this.altAndOuterContextDepth = c.altAndOuterContextDepth;
             this.context = context;
         }
 
-        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext context)
+        public static Antlr4.Runtime.Atn.ATNConfig Create([NotNull] ATNState state, int alt, [Nullable] PredictionContext context)
         {
             return Create(state, alt, context, Antlr4.Runtime.Atn.SemanticContext.None, null);
         }
 
-        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext context, Antlr4.Runtime.Atn.SemanticContext semanticContext)
+        public static Antlr4.Runtime.Atn.ATNConfig Create([NotNull] ATNState state, int alt, [Nullable] PredictionContext context, [NotNull] Antlr4.Runtime.Atn.SemanticContext semanticContext)
         {
             return Create(state, alt, context, semanticContext, null);
         }
 
-        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext context, Antlr4.Runtime.Atn.SemanticContext semanticContext, LexerActionExecutor lexerActionExecutor)
+        public static Antlr4.Runtime.Atn.ATNConfig Create([NotNull] ATNState state, int alt, [Nullable] PredictionContext context, [NotNull] Antlr4.Runtime.Atn.SemanticContext semanticContext, LexerActionExecutor lexerActionExecutor)
         {
             if (semanticContext != Antlr4.Runtime.Atn.SemanticContext.None)
             {
@@ -208,27 +208,27 @@ public Antlr4.Runtime.Atn.ATNConfig Clone()
             return Transform(this.State, false);
         }
 
-        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, bool checkNonGreedy)
+        public Antlr4.Runtime.Atn.ATNConfig Transform([NotNull] ATNState state, bool checkNonGreedy)
         {
             return Transform(state, this.context, this.SemanticContext, checkNonGreedy, this.ActionExecutor);
         }
 
-        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, Antlr4.Runtime.Atn.SemanticContext semanticContext, bool checkNonGreedy)
+        public Antlr4.Runtime.Atn.ATNConfig Transform([NotNull] ATNState state, [NotNull] Antlr4.Runtime.Atn.SemanticContext semanticContext, bool checkNonGreedy)
         {
             return Transform(state, this.context, semanticContext, checkNonGreedy, this.ActionExecutor);
         }
 
-        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext context, bool checkNonGreedy)
+        public Antlr4.Runtime.Atn.ATNConfig Transform([NotNull] ATNState state, [Nullable] PredictionContext context, bool checkNonGreedy)
         {
             return Transform(state, context, this.SemanticContext, checkNonGreedy, this.ActionExecutor);
         }
 
-        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, LexerActionExecutor lexerActionExecutor, bool checkNonGreedy)
+        public Antlr4.Runtime.Atn.ATNConfig Transform([NotNull] ATNState state, LexerActionExecutor lexerActionExecutor, bool checkNonGreedy)
         {
             return Transform(state, context, this.SemanticContext, checkNonGreedy, lexerActionExecutor);
         }
 
-        private Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext context, Antlr4.Runtime.Atn.SemanticContext semanticContext, bool checkNonGreedy, LexerActionExecutor lexerActionExecutor)
+        private Antlr4.Runtime.Atn.ATNConfig Transform([NotNull] ATNState state, [Nullable] PredictionContext context, [NotNull] Antlr4.Runtime.Atn.SemanticContext semanticContext, bool checkNonGreedy, LexerActionExecutor lexerActionExecutor)
         {
             bool passedThroughNonGreedy = checkNonGreedy && CheckNonGreedyDecision(this, state);
             if (semanticContext != Antlr4.Runtime.Atn.SemanticContext.None)
@@ -481,13 +481,13 @@ private class SemanticContextATNConfig : ATNConfig
             [NotNull]
             private readonly Antlr4.Runtime.Atn.SemanticContext semanticContext;
 
-            public SemanticContextATNConfig(Antlr4.Runtime.Atn.SemanticContext semanticContext, ATNState state, int alt, PredictionContext context)
+            public SemanticContextATNConfig(Antlr4.Runtime.Atn.SemanticContext semanticContext, [NotNull] ATNState state, int alt, [Nullable] PredictionContext context)
                 : base(state, alt, context)
             {
                 this.semanticContext = semanticContext;
             }
 
-            public SemanticContextATNConfig(Antlr4.Runtime.Atn.SemanticContext semanticContext, ATNConfig c, ATNState state, PredictionContext context)
+            public SemanticContextATNConfig(Antlr4.Runtime.Atn.SemanticContext semanticContext, [NotNull] ATNConfig c, [NotNull] ATNState state, [Nullable] PredictionContext context)
                 : base(c, state, context)
             {
                 this.semanticContext = semanticContext;
@@ -508,14 +508,14 @@ private class ActionATNConfig : ATNConfig
 
             private readonly bool passedThroughNonGreedyDecision;
 
-            public ActionATNConfig(LexerActionExecutor lexerActionExecutor, ATNState state, int alt, PredictionContext context, bool passedThroughNonGreedyDecision)
+            public ActionATNConfig(LexerActionExecutor lexerActionExecutor, [NotNull] ATNState state, int alt, [Nullable] PredictionContext context, bool passedThroughNonGreedyDecision)
                 : base(state, alt, context)
             {
                 this.lexerActionExecutor = lexerActionExecutor;
                 this.passedThroughNonGreedyDecision = passedThroughNonGreedyDecision;
             }
 
-            protected internal ActionATNConfig(LexerActionExecutor lexerActionExecutor, ATNConfig c, ATNState state, PredictionContext context, bool passedThroughNonGreedyDecision)
+            protected internal ActionATNConfig(LexerActionExecutor lexerActionExecutor, [NotNull] ATNConfig c, [NotNull] ATNState state, [Nullable] PredictionContext context, bool passedThroughNonGreedyDecision)
                 : base(c, state, context)
             {
                 if (c.SemanticContext != SemanticContext.None)
@@ -549,14 +549,14 @@ private class ActionSemanticContextATNConfig : ATNConfig.SemanticContextATNConfi
 
             private readonly bool passedThroughNonGreedyDecision;
 
-            public ActionSemanticContextATNConfig(LexerActionExecutor lexerActionExecutor, SemanticContext semanticContext, ATNState state, int alt, PredictionContext context, bool passedThroughNonGreedyDecision)
+            public ActionSemanticContextATNConfig(LexerActionExecutor lexerActionExecutor, [NotNull] SemanticContext semanticContext, [NotNull] ATNState state, int alt, [Nullable] PredictionContext context, bool passedThroughNonGreedyDecision)
                 : base(semanticContext, state, alt, context)
             {
                 this.lexerActionExecutor = lexerActionExecutor;
                 this.passedThroughNonGreedyDecision = passedThroughNonGreedyDecision;
             }
 
-            public ActionSemanticContextATNConfig(LexerActionExecutor lexerActionExecutor, SemanticContext semanticContext, ATNConfig c, ATNState state, PredictionContext context, bool passedThroughNonGreedyDecision)
+            public ActionSemanticContextATNConfig(LexerActionExecutor lexerActionExecutor, [NotNull] SemanticContext semanticContext, [NotNull] ATNConfig c, [NotNull] ATNState state, [Nullable] PredictionContext context, bool passedThroughNonGreedyDecision)
                 : base(semanticContext, c, state, context)
             {
                 this.lexerActionExecutor = lexerActionExecutor;

runtime/CSharp/Antlr4.Runtime/Atn/ATNConfigSet.cs

@@ -264,7 +264,7 @@ public virtual bool Add(ATNConfig e)
             return Add(e, null);
         }
 
-        public virtual bool Add(ATNConfig e, PredictionContextCache contextCache)
+        public virtual bool Add(ATNConfig e, [Nullable] PredictionContextCache contextCache)
         {
             EnsureWritable();
             System.Diagnostics.Debug.Assert(!outermostConfigSet || !e.ReachesIntoOuterContext);

runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializer.cs

@@ -40,8 +40,8 @@ public class ATNDeserializer
         static ATNDeserializer()
         {
             /* WARNING: DO NOT MERGE THESE LINES. If UUIDs differ during a merge,
-            * resolve the conflict by generating a new ID!
-            */
+             * resolve the conflict by generating a new ID!
+             */
             BaseSerializedUuid = new Guid("E4178468-DF95-44D0-AD87-F22A5D5FB6D3");
             AddedLexerActions = new Guid("AB35191A-1603-487E-B75A-479B831EAF6D");
             SupportedUuids = new List<Guid>();
@@ -58,7 +58,7 @@ public ATNDeserializer()
         {
         }
 
-        public ATNDeserializer(ATNDeserializationOptions deserializationOptions)
+        public ATNDeserializer([Nullable] ATNDeserializationOptions deserializationOptions)
         {
             if (deserializationOptions == null)
             {
@@ -109,7 +109,7 @@ protected internal virtual bool IsFeatureSupported(Guid feature, Guid actualUuid
             return SupportedUuids.IndexOf(actualUuid) >= featureIndex;
         }
 
-        public virtual ATN Deserialize(char[] data)
+        public virtual ATN Deserialize([NotNull] char[] data)
         {
             data = (char[])data.Clone();
             // don't adjust the first value since that's the version number
@@ -582,7 +582,7 @@ public virtual ATN Deserialize(char[] data)
         /// correct value.
         /// </summary>
         /// <param name="atn">The ATN.</param>
-        protected internal virtual void MarkPrecedenceDecisions(ATN atn)
+        protected internal virtual void MarkPrecedenceDecisions([NotNull] ATN atn)
         {
             // Map rule index -> precedence decision for that rule
             IDictionary<int, StarLoopEntryState> rulePrecedenceDecisions = new Dictionary<int, StarLoopEntryState>();
@@ -593,9 +593,9 @@ protected internal virtual void MarkPrecedenceDecisions(ATN atn)
                     continue;
                 }
                 /* We analyze the ATN to determine if this ATN decision state is the
-                * decision for the closure block that determines whether a
-                * precedence rule should continue or complete.
-                */
+                 * decision for the closure block that determines whether a
+                 * precedence rule should continue or complete.
+                 */
                 if (atn.ruleToStartState[state.ruleIndex].isPrecedenceRule)
                 {
                     ATNState maybeLoopEndState = state.Transition(state.NumberOfTransitions - 1).target;
@@ -1120,7 +1120,7 @@ protected internal static Guid ToUUID(char[] data, int offset)
         }
 
         [return: NotNull]
-        protected internal virtual Transition EdgeFactory(ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets)
+        protected internal virtual Transition EdgeFactory([NotNull] ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets)
         {
             ATNState target = atn.states[trg];
             switch (type)

runtime/CSharp/Antlr4.Runtime/Atn/ATNSimulator.cs

@@ -35,7 +35,7 @@ public abstract class ATNSimulator
         [NotNull]
         public readonly ATN atn;
 
-        public ATNSimulator(ATN atn)
+        public ATNSimulator([NotNull] ATN atn)
         {
             this.atn = atn;
         }
@@ -60,7 +60,7 @@ public virtual void ClearDFA()
         }
 
         [Obsolete(@"Use ATNDeserializer.Deserialize(char[]) instead.")]
-        public static ATN Deserialize(char[] data)
+        public static ATN Deserialize([NotNull] char[] data)
         {
             return new ATNDeserializer().Deserialize(data);
         }
@@ -103,7 +103,7 @@ public static Guid ToUUID(char[] data, int offset)
 
         [return: NotNull]
         [Obsolete(@"Use ATNDeserializer.EdgeFactory(ATN, TransitionType, int, int, int, int, int, System.Collections.Generic.IList{E}) instead.")]
-        public static Transition EdgeFactory(ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets)
+        public static Transition EdgeFactory([NotNull] ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets)
         {
             return new ATNDeserializer().EdgeFactory(atn, type, src, trg, arg1, arg2, arg3, sets);
         }
@@ -113,16 +113,16 @@ public static ATNState StateFactory(StateType type, int ruleIndex)
         {
             return new ATNDeserializer().StateFactory(type, ruleIndex);
         }
-        /*
-        public static void dump(DFA dfa, Grammar g) {
-        DOTGenerator dot = new DOTGenerator(g);
-        String output = dot.getDOT(dfa, false);
-        System.out.println(output);
-        }
-        
-        public static void dump(DFA dfa) {
-        dump(dfa, null);
-        }
-        */
+/*
+	public static void dump(DFA dfa, Grammar g) {
+		DOTGenerator dot = new DOTGenerator(g);
+		String output = dot.getDOT(dfa, false);
+		System.out.println(output);
+	}
+
+	public static void dump(DFA dfa) {
+		dump(dfa, null);
+	}
+	 */
     }
 }

runtime/CSharp/Antlr4.Runtime/Atn/ActionTransition.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Terence Parr, Sam Harwell. All Rights Reserved.
 // Licensed under the BSD License. See LICENSE.txt in the project root for license information.
 
+using Antlr4.Runtime.Misc;
 using Antlr4.Runtime.Sharpen;
 
 namespace Antlr4.Runtime.Atn
@@ -13,12 +14,12 @@ public sealed class ActionTransition : Transition
 
         public readonly bool isCtxDependent;
 
-        public ActionTransition(ATNState target, int ruleIndex)
+        public ActionTransition([NotNull] ATNState target, int ruleIndex)
             : this(target, ruleIndex, -1, false)
         {
         }
 
-        public ActionTransition(ATNState target, int ruleIndex, int actionIndex, bool isCtxDependent)
+        public ActionTransition([NotNull] ATNState target, int ruleIndex, int actionIndex, bool isCtxDependent)
             : base(target)
         {
             // e.g., $i ref in action

runtime/CSharp/Antlr4.Runtime/Atn/AmbiguityInfo.cs

@@ -65,7 +65,7 @@ public class AmbiguityInfo : DecisionEventInfo
         /// The index at which the ambiguity was identified during
         /// prediction
         /// </param>
-        public AmbiguityInfo(int decision, SimulatorState state, BitSet ambigAlts, ITokenStream input, int startIndex, int stopIndex)
+        public AmbiguityInfo(int decision, [NotNull] SimulatorState state, [NotNull] BitSet ambigAlts, [NotNull] ITokenStream input, int startIndex, int stopIndex)
             : base(decision, state, input, startIndex, stopIndex, state.useContext)
         {
             this.ambigAlts = ambigAlts;