GraphQL PPX example about reanalyze

[cristianoc]

This is the generated code after DCE:

// Generated by BUCKLESCRIPT, PLEASE EDIT WITH CARE


var Raw = { };

var MyQuery = {
  Raw: Raw
};

export {
  MyQuery ,
  
}
/* No side effect */

[jfrolich]

I will follow this up in the 1.0 branch.

[cristianoc]

@jfrolich here's the code annotated dead by the analysis.
Looks like there are a couple of things not considered dead yet which could (e.g. serializeVariables). Good test, I can look into why.

// generated code by the PPX
module MyQuery = {
  module Raw = {
    type t = {scalarsInput: string};
  };
  [@dead "MyQuery.query"] let query = "query ($arg: VariousScalarsInput!)  {\nscalarsInput(arg: $arg)  \n}\n";
  type t = {scalarsInput: string};
  type t_variables = {arg: t_variables_VariousScalarsInput}
  and t_variables_VariousScalarsInput = {
    nullableString: option(string),
    string,
    nullableInt: option(int),
    int,
    nullableFloat: option(float),
    float,
    nullableBoolean: option(bool),
    boolean: bool,
    nullableID: option(string),
    id: string,
  };
  [@dead "MyQuery.parse"] let parse: Raw.t => t =
    (value) => (
      {

        scalarsInput: {
          let value = (value: Raw.t).scalarsInput;

          value;
        },
      }: t
    );
  [@dead "MyQuery.serialize"] let serialize: t => Raw.t =
    (value) => (
      {
        let scalarsInput = {
          let value = (value: t).scalarsInput;

          value;
        };
        {

          scalarsInput: scalarsInput,
        };
      }: Raw.t
    );
  let rec serializeVariables: t_variables => Js.Json.t =
    inp =>
      [|
        (
          "arg",
          (a => Some(serializeInputObjectVariousScalarsInput(a)))(inp.arg),
        ),
      |]
      |> Js.Array.filter(
           fun
           | (_, None) => false
           | (_, Some(_)) => true,
         )
      |> Js.Array.map(
           fun
           | (k, Some(v)) => (k, v)
           | (k, None) => (k, Js.Json.null),
         )
      |> Js.Dict.fromArray
      |> Js.Json.object_
  and serializeInputObjectVariousScalarsInput:
    t_variables_VariousScalarsInput => Js.Json.t =
    inp =>
      [|
        (
          "nullableString",
          (
            a =>
              switch (a) {
              | None => None
              | Some(b) => (a => Some(Js.Json.string(a)))(b)
              }
          )(
            inp.nullableString,
          ),
        ),
        ("string", (a => Some(Js.Json.string(a)))(inp.string)),
        (
          "nullableInt",
          (
            a =>
              switch (a) {
              | None => None
              | Some(b) => (a => Some(Js.Json.number(float_of_int(a))))(b)
              }
          )(
            inp.nullableInt,
          ),
        ),
        ("int", (a => Some(Js.Json.number(float_of_int(a))))(inp.int)),
        (
          "nullableFloat",
          (
            a =>
              switch (a) {
              | None => None
              | Some(b) => (a => Some(Js.Json.number(a)))(b)
              }
          )(
            inp.nullableFloat,
          ),
        ),
        ("float", (a => Some(Js.Json.number(a)))(inp.float)),
        (
          "nullableBoolean",
          (
            a =>
              switch (a) {
              | None => None
              | Some(b) => (a => Some(Js.Json.boolean(a)))(b)
              }
          )(
            inp.nullableBoolean,
          ),
        ),
        ("boolean", (a => Some(Js.Json.boolean(a)))(inp.boolean)),
        (
          "nullableID",
          (
            a =>
              switch (a) {
              | None => None
              | Some(b) => (a => Some(Js.Json.string(a)))(b)
              }
          )(
            inp.nullableID,
          ),
        ),
        ("id", (a => Some(Js.Json.string(a)))(inp.id)),
      |]
      |> Js.Array.filter(
           fun
           | (_, None) => false
           | (_, Some(_)) => true,
         )
      |> Js.Array.map(
           fun
           | (k, Some(v)) => (k, v)
           | (k, None) => (k, Js.Json.null),
         )
      |> Js.Dict.fromArray
      |> Js.Json.object_;
  let makeVar = (~f, ~arg, ()) =>
    f(
      serializeVariables(
        {

          arg: arg,
        }: t_variables,
      ),
    )
  [@dead "MyQuery.makeInputObjectVariousScalarsInput"] and makeInputObjectVariousScalarsInput =
      (
        ~nullableString=?,
        ~string,
        ~nullableInt=?,
        ~int,
        ~nullableFloat=?,
        ~float,
        ~nullableBoolean=?,
        ~boolean,
        ~nullableID=?,
        ~id,
        (),
      )
      : t_variables_VariousScalarsInput => {

    nullableString,

    string,

    nullableInt,

    int,

    nullableFloat,

    float,

    nullableBoolean,

    boolean,

    nullableID,

    id,
  };
  [@dead "MyQuery.definition"] let definition = (parse, query, makeVar, serialize);
  let makeVariables = makeVar(~f=f => f);
};
// end of generated code by the ppx

[cristianoc]

So it looks like this is what prevents the final bit of elimination:

Warning Dead Value With Side Effects
  /Users/cristianoc/reasonml/reanalyze/examples/deadcode/src/B.re 194:3-40
  MyQuery.makeVariables is never used and could have side effects

[cristianoc]

This change would allow the full dead code analysis to fire:

  let makeVariables = (~arg) => makeVar( ~f=f => f, arg);

Or, using uncurried application would have forced one into this anyway.

This is one more example of the pitfalls of partial application. In this case, it prevents some analysis optimizaion, and surely a bunch of invisible compiler optimizations are prevented by this.

[cristianoc]

@jfrolich do you have the bandwidth to try and suggest this change upstream in the PPX and follow it through?

This example is on pause at the moment. I'd like to investigate what happens when a subset of the generated code is used. But first I'd like to make sure that if none is used, then everything is eliminated.

[jfrolich]

@jfrolich do you have the bandwidth to try and suggest this change upstream in the PPX and follow it through?

This example is on pause at the moment. I'd like to investigate what happens when a subset of the generated code is used. But first I'd like to make sure that if none is used, then everything is eliminated.

Yes. I think we might be able to eliminate makeVar it was mostly a proof of concept to enable a fancy API surface, but it had other downsides with currying, and to my knowledge it didn't end up implemented in a client. This is exactly the kind of API changes we can make before releasing 1.0 officially.

[cristianoc]

@jfrolich any other changes to report for gql ppx 1.0?

[jfrolich]

Yes there will be quite a few changes. I am looking to make the definition a record instead of a tuple (not sure yet about that though). And there is quite a list of things to be done. I made a list here: teamwalnut/graphql-ppx#86, but it is not exhaustive. Anything particular that you are interested about?

[cristianoc]

Build speed comes to mind! We ran some benchmarks lately, and the ppx can really make a difference.

[jfrolich]

Yes. I think there is much room to improve indeed! I yet have to look at performance, still some features to complete, but after that I will dive a bit deeper to improve the performance!

[cristianoc]

@jfrolich I was curious about progress and took a look at teamwalnut/graphql-ppx#86 . Wow lots of activity there!

[jfrolich]

Yes working towards a 1.0 release. We want it to be great!

[cristianoc]

Looks like this is going to work in the next release.
Please reopen if there are any new issues.