anchor.diff:          metaArgs = []
       }]
   
  -let metaRules nonTerm body args : Rule.t<_,_> list = 
  +let metaRules nonTerm body args : Rule.t<_,_> list =
       [{
           name = Source.t nonTerm
           args = []
  
positive.code:         let rMap = new System.Collections.Generic.Dictionary<_,_>()
          module'.openings
          |> List.iter (fun op ->
              try 
                  publicRules.[op.text] |> List.iter (fun r ->
                      try 
                          rMap.[r.name.text] <- op.text
                      with
                      | e -> printfn "Get rules error: rule name: %A;" r.name.text
  
                          )
              with
              | e -> printfn "Get rules error: open: %A;" op.text  
              
          )
          module'.rules |> List.iter (fun r -> rMap.[r.name.text] <- getModuleName module')
          getModuleName module', rMap
  
negative.code:         )
      |> dict
  
  let rec getAllNonTermOfProd (prod : Production.t<_,_>) =
      let inline getNonTermOfLst prodList = List.collect getAllNonTermOfProd prodList
  
      match prod with
      |PAlt(prod1, prod2)
      |PConj(prod1, prod2) -> List.append (getAllNonTermOfProd prod1) (getAllNonTermOfProd prod2)
      |PNeg prod -> getAllNonTermOfProd prod
      |PSeq(prodList, _, _) -> getNonTermOfLst << List.map (fun elem -> elem.rule) <| prodList
      |PToken(_) -> []
      |PRef(nonTerm, _) -> List.singleton nonTerm
      |PMany prod -> getAllNonTermOfProd prod
      |PMetaRef(ref, _, prodList) -> ref :: getNonTermOfLst prodList
      |PLiteral lit -> List.empty
      |PRepet(prod, _, _) -> getAllNonTermOfProd prod
      |PPerm prodList -> getNonTermOfLst prodList
      |PSome prod -> getAllNonTermOfProd prod
      |POpt prod -> getAllNonTermOfProd prod
  
  /// For each module creates map: rule -> (module, in which the rule is declared)
  let getRulesMap (grammar : Grammar.t<_,_>) =
      let publicRules = getPublicRules grammar
  