Function makeParser

packages/effect/src/SchemaParser.ts:1081–1219

(
  ast: SchemaAST.AST,
  compile: Compiler,
  compileConstructorDefault?: Compiler,
  constructorDefault?: SchemaAST.Link
)

}

function makeParser(
  ast: SchemaAST.AST,
  compile: Compiler,
  compileConstructorDefault?: Compiler,
  constructorDefault?: SchemaAST.Link
): Parser {
  const descriptor = compileConstructorDefault ? SchemaAST.getConstructorDescriptor(ast) : undefined
  const parser = descriptor
    ? makeConstructorParser(descriptor, compile)
    : ast.getParser(compile, compileConstructorDefault)
  const checks = ast.checks
  const links = constructorDefault
    ? ast.encoding ? [...ast.encoding, constructorDefault] : [constructorDefault]
    : ast.encoding
  const encodingChecks = (ast as any).encodingChecks
  const astOptions = (checks ? checks[checks.length - 1].annotations : ast.annotations)
    ?.["parseOptions"]
  if (!links && !checks && !encodingChecks) {
    if (!astOptions) {
      return parser
    }
    return (input, options) => parser(input, mergeParseOptions(options, astOptions))
  }
  let encodingParsers: ReadonlyArray<Parser> | undefined
  const parseLocal = (
    input: unknown,
    options: SchemaAST.ParseOptions
  ) => {
    let result = parser(input, options)
    if (encodingChecks && !options.disableChecks) {
      if (effectIsExit(result)) {
        if (result._tag === "Success") {
          const output = result === InternalParser.sameExit
            ? input
            : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
          if (input !== InternalParser.missing && output !== InternalParser.missing) {
            const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
            if (issues) {
              result = Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
            }
          }
        }
      } else {
        result = Effect.flatMap(result, (value) => {
          if (input !== InternalParser.missing && value !== InternalParser.missing) {
            const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
            if (issues) {
              return Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
            }
          }
          return Effect.succeed(value)
        })
      }
    }

    if (checks && !options.disableChecks) {
      if (effectIsExit(result)) {
        if (result._tag === "Success") {