anchor.diff:          | true -> Array.append (mangledText.[0..(count-2)]) ([| mangledText.[(count-1)..] |> String.concat (System.Char.ToString separator) |])
           | false -> mangledText
   
  -    let FSharpModuleSuffix = "Module"
  -
  -    let MangledGlobalName = "`global`"
  +    let [<Literal>] FSharpModuleSuffix = "Module"
  +
  +    let [<Literal>] MangledGlobalName = "`global`"
       
       let IllegalCharactersInTypeAndNamespaceNames = [| '.'; '+'; '$'; '&'; '['; ']'; '/'; '\\'; '*'; '\"'; '`'  |]
   
  +    /// Determines if the specified name is a valid name for an active pattern.
       let IsActivePatternName (nm:string) =
  +        let nameLen = nm.Length
  +        // The name must start and end with '|'
           (nm.IndexOf '|' = 0) &&
  -        nm.Length >= 3 &&
  -        (nm.LastIndexOf '|' = nm.Length - 1) &&
  +        (nm.LastIndexOf '|' = nameLen - 1) &&
  +        // The name must contain at least one character between the starting and ending delimiters.
  +        nameLen >= 3 &&
           (
  -           let core = nm.Substring(1, nm.Length - 2) 
  +           let core = nm.Substring(1, nameLen - 2)
              // no operator characters except '|' and ' '
  -           core |> String.forall (fun c -> c = '|' || c = ' ' || not (opCharDict.ContainsKey c)) &&
  +           core |> String.forall (fun c -> c = '|' || c = ' ' || not (opCharSet.Contains c)) &&
              // at least one non-operator or space character
  -           core |> String.exists (fun c -> c = ' ' || not (opCharDict.ContainsKey c))
  +           core |> String.exists (fun c -> c = ' ' || not (opCharSet.Contains c))
           )
   
       //IsActivePatternName "|+|" = false
  
positive.code:         //------
          // This function recognises these "infix operator" names.
          let s = DecompileOpName s
          let skipIgnoredChars = s.TrimStart('.', '?')
          let afterSkipStartsWith prefix   = skipIgnoredChars.StartsWith(prefix,System.StringComparison.Ordinal)
          let afterSkipStarts     prefixes = List.exists afterSkipStartsWith prefixes
          // The following conditions follow the declExpr infix clauses. The test corresponds to the lexer definition for the token.
          s = ":=" ||                                    // COLON_EQUALS
          afterSkipStartsWith "|" ||                     // BAR_BAR, INFIX_BAR_OP
          (* REVIEW: OR is deadcode, now called BAR? *)  // OR
          afterSkipStartsWith "&"  ||                    // AMP, AMP_AMP, INFIX_AMP_OP
          afterSkipStarts ["=";"!=";"<";">";"$"] ||      // EQUALS, INFIX_COMPARE_OP, LESS, GREATER
          s = "$" ||                                     // DOLLAR
          afterSkipStarts ["@";"^"] ||                   // INFIX_AT_HAT_OP
          s = "::" ||                                    // COLON_COLON
          afterSkipStarts ["+";"-"] ||                   // PLUS_MINUS_OP, MINUS
          afterSkipStarts ["*";"/";"%"] ||               // PERCENT_OP, STAR, INFIX_STAR_DIV_MOD_OP
          s = "**"                                       // INFIX_STAR_STAR_OP
  
      let (|Control|Equality|Relational|Indexer|FixedTypes|Other|) opName = 
          if (opName = "&" || opName = "or" || opName = "&&" || opName = "||") then Control
          elif (opName = "<>" || opName = "=" ) then Equality
          elif (opName = "<" || opName = ">" || opName = "<=" || opName = ">=") then Relational
          elif (opName = "<<" || opName = "<|" || opName = "<||" || opName = "<||" || opName = "|>" || opName = "||>" || opName = "|||>" || opName = ">>" || opName = "^" || opName = ":=" || opName = "@") then FixedTypes
          elif (opName = ".[]" ) then Indexer
          else Other
  
      let private compilerGeneratedMarker = "@"
      let private compilerGeneratedMarkerChar = '@'
      
      let IsCompilerGeneratedName (nm:string) =
          nm.IndexOf compilerGeneratedMarkerChar <> -1
  
negative.code:     let opNameNullableEquals = CompileOpName "?="
      let opNameNullableEqualsNullable = CompileOpName "?=?"
  
      /// The characters that are allowed to be the first character of an identifier.
      let IsIdentifierFirstCharacter c =
          if c = '_' then true
          else
              match System.Char.GetUnicodeCategory c with
              // Letters
              | UnicodeCategory.UppercaseLetter
              | UnicodeCategory.LowercaseLetter
              | UnicodeCategory.TitlecaseLetter
              | UnicodeCategory.ModifierLetter
              | UnicodeCategory.OtherLetter
              | UnicodeCategory.LetterNumber -> true
              | _ -> false
  
      /// The characters that are allowed to be in an identifier.
      let IsIdentifierPartCharacter c =
          if c = '\'' then true   // Tick
          else
              match System.Char.GetUnicodeCategory c with
              // Letters
              | UnicodeCategory.UppercaseLetter
              | UnicodeCategory.LowercaseLetter
              | UnicodeCategory.TitlecaseLetter
              | UnicodeCategory.ModifierLetter
              | UnicodeCategory.OtherLetter
              | UnicodeCategory.LetterNumber
              // Numbers
              | UnicodeCategory.DecimalDigitNumber
              // Connectors
              | UnicodeCategory.ConnectorPunctuation
              // Combiners
              | UnicodeCategory.NonSpacingMark
              | UnicodeCategory.SpacingCombiningMark -> true
              | _ -> false
  
      /// Is this character a part of a long identifier?
      let IsLongIdentifierPartCharacter c =
          c = '.'
          || IsIdentifierPartCharacter c
  
      let IsValidPrefixOperatorUse s =
          if System.String.IsNullOrEmpty s then false else
          match s with 
          | "?+" | "?-" | "+" | "-" | "+." | "-." | "%" | "%%" | "&" | "&&" -> true
          | _ ->
              s.[0] = '!'
              // The check for the first character here could be eliminated since it's covered
              // by the call to String.forall; it is a fast check used to avoid the call if possible.
              || (s.[0] = '~' && String.forall (fun c -> c = '~') s)
      
      let IsValidPrefixOperatorDefinitionName s = 
          if System.String.IsNullOrEmpty s then false else
          match s with 
          | "~?+" | "~?-" | "~+" | "~-" | "~+." | "~-." | "~%" | "~%%" | "~&" | "~&&" -> true
          | _ ->
              (s.[0] = '!' && s <> "!=")
              // The check for the first character here could be eliminated since it's covered
              // by the call to String.forall; it is a fast check used to avoid the call if possible.
              || (s.[0] = '~' && String.forall (fun c -> c = '~') s)
          
      let IsPrefixOperator s =
          if System.String.IsNullOrEmpty s then false else
          let s = DecompileOpName s
          match s with 
          | "~?+" | "~?-" | "~+" | "~-" | "~+." | "~-." | "~%" | "~%%" | "~&" | "~&&" -> true
          | _ ->
              (s.[0] = '!' && s <> "!=")
              // The check for the first character here could be eliminated since it's covered
              // by the call to String.forall; it is a fast check used to avoid the call if possible.
              || (s.[0] = '~' && String.forall (fun c -> c = '~') s)
  
      let IsTernaryOperator s = 
          (DecompileOpName s = qmarkSet)
  
      let IsInfixOperator =
          /// EQUALS, INFIX_COMPARE_OP, LESS, GREATER
          let relational = [| "=";"!=";"<";">";"$"|]
          /// INFIX_AT_HAT_OP
          let concat = [| "@";"^" |]
          /// PLUS_MINUS_OP, MINUS
          let plusMinus = [| "+"; "-" |]
          /// PERCENT_OP, STAR, INFIX_STAR_DIV_MOD_OP
          let otherMath = [| "*";"/";"%" |]
  
          /// Characters ignored at the start of the operator name
          /// when determining whether an operator is an infix operator.
          let ignoredChars = [| '.'; '?' |]
  
          fun s (* where s is assumed to be a compiled name *) ->
          // Certain operator idents are parsed as infix expression operators.
          // The parsing as infix operators is hardwired in the grammar [see declExpr productions]
          // where certain operator tokens are accepted in infix forms, i.e. <expr> <op> <expr>.
  