Rename source position module

lib/ast.ml

@@ -1,8 +1,10 @@
+open Source_pos
+
 type typeRef =
-  | Tr_named of string SourcePos.spanning
-  | Tr_list of typeRef SourcePos.spanning
-  | Tr_non_null_named of string SourcePos.spanning
-  | Tr_non_null_list of typeRef SourcePos.spanning
+  | Tr_named of string spanning
+  | Tr_list of typeRef spanning
+  | Tr_non_null_named of string spanning
+  | Tr_non_null_list of typeRef spanning
 
 type input_value =
   | Iv_null
@@ -12,66 +14,66 @@ type input_value =
   | Iv_boolean of bool
   | Iv_enum of string
   | Iv_variable of string
-  | Iv_list of input_value SourcePos.spanning list
-  | Iv_object of (string SourcePos.spanning * input_value SourcePos.spanning) list
+  | Iv_list of input_value spanning list
+  | Iv_object of (string spanning * input_value spanning) list
 
 type variable_definition = {
-  vd_type: typeRef SourcePos.spanning;
-  vd_default_value: input_value SourcePos.spanning option
+  vd_type: typeRef spanning;
+  vd_default_value: input_value spanning option
 }
 
-type variable_definitions = (string SourcePos.spanning * variable_definition) list
+type variable_definitions = (string spanning * variable_definition) list
 
-type arguments = (string SourcePos.spanning * input_value SourcePos.spanning) list
+type arguments = (string spanning * input_value spanning) list
 
 type directive = { 
-  d_name: string SourcePos.spanning;
-  d_arguments: arguments SourcePos.spanning option;
+  d_name: string spanning;
+  d_arguments: arguments spanning option;
 }
 
 type fragment_spread = {
-  fs_name: string SourcePos.spanning;
-  fs_directives: directive SourcePos.spanning list
+  fs_name: string spanning;
+  fs_directives: directive spanning list
 }
 
 type field = {
-  fd_alias: string SourcePos.spanning option;
-  fd_name: string SourcePos.spanning;
-  fd_arguments: arguments SourcePos.spanning option;
-  fd_directives: directive SourcePos.spanning list;
-  fd_selection_set: selection list SourcePos.spanning option;
+  fd_alias: string spanning option;
+  fd_name: string spanning;
+  fd_arguments: arguments spanning option;
+  fd_directives: directive spanning list;
+  fd_selection_set: selection list spanning option;
 }
 
 and inlineFragment = {
-  if_type_condition: string SourcePos.spanning option;
-  if_directives: directive SourcePos.spanning list;
-  if_selection_set: selection list SourcePos.spanning;
+  if_type_condition: string spanning option;
+  if_directives: directive spanning list;
+  if_selection_set: selection list spanning;
 }
 
 and selection =
-  | Field of field SourcePos.spanning
-  | FragmentSpread of fragment_spread SourcePos.spanning
-  | InlineFragment of inlineFragment SourcePos.spanning
+  | Field of field spanning
+  | FragmentSpread of fragment_spread spanning
+  | InlineFragment of inlineFragment spanning
 
 type operationType = Query | Mutation
 
 type operation = {
   o_type: operationType;
-  o_name: string SourcePos.spanning option;
-  o_variable_definitions: variable_definitions SourcePos.spanning option;
-  o_directives: directive SourcePos.spanning list;
-  o_selection_set: selection list SourcePos.spanning;
+  o_name: string spanning option;
+  o_variable_definitions: variable_definitions spanning option;
+  o_directives: directive spanning list;
+  o_selection_set: selection list spanning;
 }
 
 type fragment = {
-  fg_name: string SourcePos.spanning;
-  fg_type_condition: string SourcePos.spanning;
-  fg_directives: directive SourcePos.spanning list;
-  fg_selection_set: selection list SourcePos.spanning;
+  fg_name: string spanning;
+  fg_type_condition: string spanning;
+  fg_directives: directive spanning list;
+  fg_selection_set: selection list spanning;
 }
 
 type definition =
-  | Operation of operation SourcePos.spanning
-  | Fragment of fragment SourcePos.spanning
+  | Operation of operation spanning
+  | Fragment of fragment spanning
 
 type document = definition list

lib/document.ml

@@ -2,7 +2,7 @@ open Result
 open Ast
 
 open Gql_parser
-open SourcePos
+open Source_pos
 
 let last l = match List.length l with
   | 0 -> None
@@ -73,7 +73,7 @@ let rec parse_type parser = match skip parser Gql_lexer.Bracket_open with
       | { item = Gql_lexer.Exclamation_mark; span = _, end_pos } ->
         let _ = next parser in
         Ok (start_end (start_pos name_span) end_pos (Tr_non_null_named name_span))
-      | _ -> Ok (SourcePos.replace name_span (Tr_named name_span))
+      | _ -> Ok (replace name_span (Tr_named name_span))
 
 let parse_variable_definition parser = match expect parser Gql_lexer.Dollar with
   | Error e -> Error e
@@ -107,7 +107,7 @@ let parse_variable_definition parser = match expect parser Gql_lexer.Dollar with
 
 let parse_variable_definitions parser = match peek parser with
   | { item = Gql_lexer.Paren_open } ->
-    map_ok (fun span -> Some (SourcePos.map (fun items -> List.map (fun s -> s.item) items) span))
+    map_ok (fun span -> Some (map (fun items -> List.map (fun s -> s.item) items) span))
       (delimited_nonempty_list parser Gql_lexer.Paren_open parse_variable_definition Gql_lexer.Paren_close)
   | _ -> Ok None
 
@@ -211,24 +211,24 @@ and parse_fragment parser =
       end
     | _ -> match next parser with
       | Error e -> Error e
-      | Ok span -> Error (SourcePos.map (fun t -> Unexpected_token t) span)
+      | Ok span -> Error (map (fun t -> Unexpected_token t) span)
 
 and parse_selection parser =
   match peek parser with
   | { item = Gql_lexer.Ellipsis } -> parse_fragment parser
-  | _ -> map_ok (fun (span: Ast.field SourcePos.spanning) -> Ast.Field span) (parse_field parser)
+  | _ -> map_ok (fun (span: Ast.field spanning) -> Ast.Field span) (parse_field parser)
 
 let parse_operation_type parser = match next parser with
   | Error e -> Error e
-  | Ok ({ item = Gql_lexer.Name "query" } as span) -> Ok (SourcePos.replace span Ast.Query)
-  | Ok ({ item = Gql_lexer.Name "mutation"} as span) -> Ok (SourcePos.replace span Ast.Mutation)
-  | Ok span -> Error (SourcePos.map (fun t -> Unexpected_token t) span)
+  | Ok ({ item = Gql_lexer.Name "query" } as span) -> Ok (replace span Ast.Query)
+  | Ok ({ item = Gql_lexer.Name "mutation"} as span) -> Ok (replace span Ast.Mutation)
+  | Ok span -> Error (map (fun t -> Unexpected_token t) span)
 
 let parse_operation_definition parser =
   match peek parser with
   | { item = Gql_lexer.Curly_open } -> begin match parse_selection_set parser with
     | Error e -> Error e
-    | Ok span -> Ok (SourcePos.replace span {
+    | Ok span -> Ok (replace span {
         o_type = Query;
         o_name = None;
         o_variable_definitions = None;
@@ -269,7 +269,7 @@ let parse_fragment_definition parser = match expect parser (Gql_lexer.Name "frag
   | Error e -> Error e
   | Ok { span = start_pos, _ } -> match expect_name parser with
     | Error e -> Error e
-    | Ok ({ item = "on" } as span) -> Error (SourcePos.replace span (Unexpected_token (Gql_lexer.Name "on")))
+    | Ok ({ item = "on" } as span) -> Error (replace span (Unexpected_token (Gql_lexer.Name "on")))
     | Ok name_span -> match expect parser (Gql_lexer.Name "on") with
       | Error e -> Error e
       | Ok _ -> match expect_name parser with
@@ -294,7 +294,7 @@ let parse_definition parser =
     map_ok (fun def -> Ast.Operation def) (parse_operation_definition parser)
   | { item = Gql_lexer.Name "fragment" } ->
     map_ok (fun def -> Ast.Fragment def) (parse_fragment_definition parser)
-  | span -> Error (SourcePos.map (fun t -> Unexpected_token t) span)
+  | span -> Error (map (fun t -> Unexpected_token t) span)
 
 let parse_document parser =
   let rec scanner acc = match parse_definition parser with

lib/gql_lexer.ml

@@ -1,6 +1,6 @@
 open Result
 
-open SourcePos
+open Source_pos
 
 let map_some f o = match o with
   | Some v -> Some (f v)
@@ -9,7 +9,7 @@ let map_some f o = match o with
 type lexer = {
   source: string;
   length: int;
-  mutable position: sourcePosition;
+  mutable position: source_position;
   mutable has_reached_eof: bool;
 }
 

lib/gql_parser.ml

@@ -1,5 +1,5 @@
 open Result
-open SourcePos
+open Source_pos
 
 let map_ok f r = match r with
   | Ok x -> Ok (f x)

lib/gql_printer.ml

@@ -1,5 +1,5 @@
 open Ast
-open SourcePos
+open Source_pos
 
 let rec print_input_value iv = match iv with
   | Iv_null -> "null"

lib/graphql_ppx.ml

@@ -4,11 +4,10 @@ module To_current = Convert(OCaml_404)(OCaml_current)
 
 open Ast_404
 
-open SourcePos
+open Source_pos
 
 let add_pos delimLength base pos =
   let open Lexing in
-  let open SourcePos in
   let (_, _, col) = Location.get_pos_info base in
   {
     pos_fname = base.pos_fname;
@@ -19,7 +18,6 @@ let add_pos delimLength base pos =
 
 let add_loc delimLength base span =
   let open Location in
-  let open SourcePos in
   {
     loc_start = add_pos delimLength base.loc_start (fst span);
     loc_end = add_pos delimLength base.loc_start (snd span);
@@ -78,13 +76,13 @@ let mapper () =
             let delimLength = match delim with | Some s -> 2 + String.length s | None -> 1 in
             match Gql_lexer.consume lexer with
             | Result.Error e -> raise (Location.Error (
-                Location.error ~loc:(add_loc delimLength loc e.span) (fmt_lex_err e.SourcePos.item)
+                Location.error ~loc:(add_loc delimLength loc e.span) (fmt_lex_err e.item)
               ))
             | Result.Ok tokens -> 
               let parser = Gql_parser.make tokens in
               match Document.parse_document parser with
               | Result.Error e -> raise (Location.Error (
-                  Location.error ~loc:(add_loc delimLength loc e.span) (fmt_parse_err e.SourcePos.item)
+                  Location.error ~loc:(add_loc delimLength loc e.span) (fmt_parse_err e.item)
                 ))
               | Result.Ok document ->
                 let reprinted_query = Gql_printer.print_document document in

lib/sourcePos.ml → lib/source_pos.ml

@@ -1,12 +1,12 @@
-type sourcePosition = {
+type source_position = {
   index: int;
   line: int;
   col: int;
 }
 
 type 'a spanning = {
   item: 'a;
-  span: sourcePosition * sourcePosition;
+  span: source_position * source_position;
 }
 
 let origin = { index = 0; line = 0; col = 0 }

lib/unifier.ml

@@ -1,5 +1,5 @@
 open Ast
-open SourcePos
+open Source_pos
 open Schema
 
 open Ast_404
@@ -79,7 +79,7 @@ let make_match_fun loc decoder none_arm some_arm =
 
 let mangle_enum_name = String.uncapitalize
 
-let rec unify_type map_loc span ty schema (selection_set: selection list SourcePos.spanning option) =
+let rec unify_type map_loc span ty schema (selection_set: selection list spanning option) =
   let loc = map_loc span in
   match ty with
   | Ntr_nullable t ->

lib/value.ml

@@ -1,7 +1,7 @@
 open Result
 
 open Gql_parser
-open SourcePos
+open Source_pos
 
 open Ast