Documentation

Lean.Parser.Extension

Extensible parsing via attributes

Instances For
    Instances For
      @[reducible, inline]
      Equations
        Instances For
          Equations
            Instances For
              @[reducible, inline]
              Equations
                Instances For
                  def Lean.Parser.addLeadingParser (categories : ParserCategories) (catName declName : Name) (p : Parser) (prio : Nat) :
                  Equations
                    Instances For
                      def Lean.Parser.addTrailingParser (categories : ParserCategories) (catName declName : Name) (p : TrailingParser) (prio : Nat) :
                      Equations
                        Instances For
                          def Lean.Parser.addParser (categories : ParserCategories) (catName declName : Name) (leading : Bool) (p : Parser) (prio : Nat) :
                          Equations
                            Instances For
                              Equations
                                Instances For
                                  Equations
                                    Instances For
                                      inductive Lean.Parser.AliasValue (α : Type) :

                                      Parser aliases for making ParserDescr extensible

                                      Instances For
                                        @[reducible, inline]
                                        Equations
                                          Instances For
                                            def Lean.Parser.registerAliasCore {α : Type} (mapRef : IO.Ref (AliasTable α)) (aliasName : Name) (value : AliasValue α) :
                                            Equations
                                              Instances For
                                                def Lean.Parser.getAlias {α : Type} (mapRef : IO.Ref (AliasTable α)) (aliasName : Name) :
                                                Equations
                                                  Instances For
                                                    def Lean.Parser.getConstAlias {α : Type} (mapRef : IO.Ref (AliasTable α)) (aliasName : Name) :
                                                    IO α
                                                    Equations
                                                      Instances For
                                                        def Lean.Parser.getUnaryAlias {α : Type} (mapRef : IO.Ref (AliasTable α)) (aliasName : Name) :
                                                        IO (αα)
                                                        Equations
                                                          Instances For
                                                            def Lean.Parser.getBinaryAlias {α : Type} (mapRef : IO.Ref (AliasTable α)) (aliasName : Name) :
                                                            IO (ααα)
                                                            Equations
                                                              Instances For
                                                                @[reducible, inline]
                                                                Equations
                                                                  Instances For
                                                                    • declName : Name
                                                                    • stackSz? : Option Nat

                                                                      Number of syntax nodes produced by this parser. none means "sum of input sizes".

                                                                    • autoGroupArgs : Bool

                                                                      Whether arguments should be wrapped in group(·) if they do not produce exactly one syntax node.

                                                                    Instances For
                                                                      Equations
                                                                        Instances For
                                                                          def Lean.Parser.registerAlias (aliasName declName : Name) (p : ParserAliasValue) (kind? : Option SyntaxNodeKind := none) (info : ParserAliasInfo := { }) :
                                                                          Equations
                                                                            Instances For
                                                                              Equations
                                                                                Instances For
                                                                                  Equations
                                                                                    Instances For
                                                                                      Equations
                                                                                        Instances For
                                                                                          Equations
                                                                                            Instances For
                                                                                              unsafe def Lean.Parser.mkParserOfConstantUnsafe (constName : Name) (compileParserDescr : ParserDescrImportM Parser) :
                                                                                              Equations
                                                                                                Instances For
                                                                                                  @[implemented_by Lean.Parser.mkParserOfConstantUnsafe]
                                                                                                  opaque Lean.Parser.mkParserOfConstantAux (constName : Name) (compileParserDescr : ParserDescrImportM Parser) :
                                                                                                  Equations
                                                                                                    Instances For
                                                                                                      Equations
                                                                                                        Instances For
                                                                                                          • postAdd (catName declName : Name) (builtin : Bool) : AttrM Unit

                                                                                                            Called after a parser attribute is applied to a declaration.

                                                                                                          Instances For
                                                                                                            def Lean.Parser.runParserAttributeHooks (catName declName : Name) (builtin : Bool) :
                                                                                                            Equations
                                                                                                              Instances For
                                                                                                                Equations
                                                                                                                  Instances For
                                                                                                                    Equations
                                                                                                                      Instances For
                                                                                                                        Equations
                                                                                                                          Instances For
                                                                                                                            Equations
                                                                                                                              Instances For
                                                                                                                                @[implemented_by Lean.Parser.evalParserConstUnsafe]

                                                                                                                                Run declName if possible and inside a quotation, or else p. The ParserInfo will always be taken from p.

                                                                                                                                Equations
                                                                                                                                  Instances For
                                                                                                                                    def Lean.Parser.addBuiltinParser (catName declName : Name) (leading : Bool) (p : Parser) (prio : Nat) :
                                                                                                                                    Equations
                                                                                                                                      Instances For
                                                                                                                                        def Lean.Parser.addBuiltinLeadingParser (catName declName : Name) (p : Parser) (prio : Nat) :
                                                                                                                                        Equations
                                                                                                                                          Instances For
                                                                                                                                            def Lean.Parser.addBuiltinTrailingParser (catName declName : Name) (p : TrailingParser) (prio : Nat) :
                                                                                                                                            Equations
                                                                                                                                              Instances For
                                                                                                                                                Equations
                                                                                                                                                  Instances For
                                                                                                                                                    Equations
                                                                                                                                                      Instances For
                                                                                                                                                        Equations
                                                                                                                                                          Instances For
                                                                                                                                                            Equations
                                                                                                                                                              Instances For
                                                                                                                                                                def Lean.Parser.mkInputContext (input fileName : String) (normalizeLineEndings : Bool := true) :
                                                                                                                                                                Equations
                                                                                                                                                                  Instances For
                                                                                                                                                                    Equations
                                                                                                                                                                      Instances For
                                                                                                                                                                        def Lean.Parser.runParserCategory (env : Environment) (catName : Name) (input : String) (fileName : String := "<input>") :

                                                                                                                                                                        convenience function for testing

                                                                                                                                                                        Equations
                                                                                                                                                                          Instances For
                                                                                                                                                                            def Lean.Parser.declareBuiltinParser (addFnName catName declName : Name) (prio : Nat) :
                                                                                                                                                                            Equations
                                                                                                                                                                              Instances For
                                                                                                                                                                                def Lean.Parser.declareLeadingBuiltinParser (catName declName : Name) (prio : Nat) :
                                                                                                                                                                                Equations
                                                                                                                                                                                  Instances For
                                                                                                                                                                                    def Lean.Parser.declareTrailingBuiltinParser (catName declName : Name) (prio : Nat) :
                                                                                                                                                                                    Equations
                                                                                                                                                                                      Instances For
                                                                                                                                                                                        Equations
                                                                                                                                                                                          Instances For
                                                                                                                                                                                            def Lean.Parser.registerBuiltinParserAttribute (attrName declName : Name) (behavior : LeadingIdentBehavior := LeadingIdentBehavior.default) (ref : Name := by exact decl_name%) :

                                                                                                                                                                                            The parsing tables for builtin parsers are "stored" in the extracted source code.

                                                                                                                                                                                            Equations
                                                                                                                                                                                              Instances For
                                                                                                                                                                                                def Lean.Parser.mkParserAttributeImpl (attrName catName : Name) (ref : Name := by exact decl_name%) :
                                                                                                                                                                                                Equations
                                                                                                                                                                                                  Instances For
                                                                                                                                                                                                    def Lean.Parser.registerBuiltinDynamicParserAttribute (attrName catName : Name) (ref : Name := by exact decl_name%) :

                                                                                                                                                                                                    A builtin parser attribute that can be extended by users.

                                                                                                                                                                                                    Equations
                                                                                                                                                                                                      Instances For
                                                                                                                                                                                                        def Lean.Parser.registerParserCategory (env : Environment) (attrName catName : Name) (behavior : LeadingIdentBehavior := LeadingIdentBehavior.default) (ref : Name := by exact decl_name%) :
                                                                                                                                                                                                        Equations
                                                                                                                                                                                                          Instances For
                                                                                                                                                                                                            @[inline]
                                                                                                                                                                                                            Equations
                                                                                                                                                                                                              Instances For
                                                                                                                                                                                                                Equations
                                                                                                                                                                                                                  Instances For

                                                                                                                                                                                                                    If the parsing stack is of the form #[.., openCommand], we process the open command, and execute p

                                                                                                                                                                                                                    Equations
                                                                                                                                                                                                                      Instances For
                                                                                                                                                                                                                        @[inline]
                                                                                                                                                                                                                        Equations
                                                                                                                                                                                                                          Instances For

                                                                                                                                                                                                                            If the parsing stack is of the form #[.., openDecl], we process the open declaration, and execute p

                                                                                                                                                                                                                            Equations
                                                                                                                                                                                                                              Instances For
                                                                                                                                                                                                                                @[inline]
                                                                                                                                                                                                                                Equations
                                                                                                                                                                                                                                  Instances For

                                                                                                                                                                                                                                    Helper environment extension that gives us access to built-in aliases in pure parser functions.

                                                                                                                                                                                                                                    Result of resolving a parser name.

                                                                                                                                                                                                                                    • category (cat : Name) : ParserResolution

                                                                                                                                                                                                                                      Reference to a category.

                                                                                                                                                                                                                                    • parser (decl : Name) (isDescr : Bool) : ParserResolution

                                                                                                                                                                                                                                      Reference to a parser declaration in the environment. A (Trailing)ParserDescr if isDescr is true.

                                                                                                                                                                                                                                    • alias (p : ParserAliasValue) : ParserResolution

                                                                                                                                                                                                                                      Reference to a parser alias. Note that as aliases are built-in, a corresponding declaration may not be in the environment (yet).

                                                                                                                                                                                                                                    Instances For
                                                                                                                                                                                                                                      def Lean.Parser.resolveParserNameCore (env : Environment) (currNamespace : Name) (openDecls : List OpenDecl) (ident : Ident) :

                                                                                                                                                                                                                                      Resolve the given parser name and return a list of candidates.

                                                                                                                                                                                                                                      Equations
                                                                                                                                                                                                                                        Instances For

                                                                                                                                                                                                                                          Resolve the given parser name and return a list of candidates.

                                                                                                                                                                                                                                          Equations
                                                                                                                                                                                                                                            Instances For

                                                                                                                                                                                                                                              Resolve the given parser name and return a list of candidates.

                                                                                                                                                                                                                                              Equations
                                                                                                                                                                                                                                                Instances For
                                                                                                                                                                                                                                                  Equations
                                                                                                                                                                                                                                                    Instances For
                                                                                                                                                                                                                                                      def Lean.Parser.parserOfStack (offset : Nat) (prec : Nat := 0) :
                                                                                                                                                                                                                                                      Equations
                                                                                                                                                                                                                                                        Instances For