@alloy-js/csharp 0.20.0-dev.6 → 0.20.0-dev.8

package/dist/src/components/access-expression/access-expression.d.ts

@@ -0,0 +1,54 @@
+import { Children, Refkey } from "@alloy-js/core";
+import { CSharpSymbol } from "../../symbols/csharp.js";
+export interface AccessExpressionProps {
+    children: Children;
+}
+export declare function AccessExpression(props: AccessExpressionProps): string | number | boolean | void | (() => Children) | import("@vue/reactivity").Ref<any, any> | import("@alloy-js/core").SymbolRefkey | import("@alloy-js/core").MemberRefkey | import("@alloy-js/core").CustomContext | import("@alloy-js/core").IndentIntrinsicElement | import("@alloy-js/core").IndentIfBreakIntrinsicElement | import("@alloy-js/core").BrIntrinsicElement | import("@alloy-js/core").LineIntrinsicElement | import("@alloy-js/core").HbrIntrinsicElement | import("@alloy-js/core").HardlineIntrinsicElement | import("@alloy-js/core").SbrIntrinsicElement | import("@alloy-js/core").SoftlineIntrinsicElement | import("@alloy-js/core").GroupIntrinsicElement | import("@alloy-js/core").AlignIntrinsicElement | import("@alloy-js/core").FillIntrinsicElement | import("@alloy-js/core").BreakParentIntrinsicElement | import("@alloy-js/core").LineSuffixIntrinsicElement | import("@alloy-js/core").LineSuffixBoundaryIntrinsicElement | import("@alloy-js/core").DedentIntrinsicElement | import("@alloy-js/core").LiterallineIntrinsicElement | import("@alloy-js/core").LbrIntrinsicElement | import("@alloy-js/core").DedentToRootIntrinsicElement | import("@alloy-js/core").MarkAsRootIntrinsicElement | import("@alloy-js/core").IfBreakIntrinsicElement | Children[] | import("@vue/reactivity").ComputedRef<Children> | null;
+export declare namespace AccessExpression {
+    var Part: (props: AccessExpressionPartProps) => void;
+}
+export interface AccessExpressionPartProps {
+    children?: Children;
+    /**
+     * Whether this part should use conditional access.
+     */
+    conditional?: boolean;
+    /**
+     * Emit a function call.
+     */
+    args?: boolean | Children[];
+    /**
+     * Type arguments to pass to a member access.
+     */
+    typeArgs?: Children[];
+    /**
+     * A refkey for the symbol whose name becomes this part's identifier. When a refkey is provided for the first
+     * part, it will be fully resolved. Otherwise, just the symbol's name is used.
+     */
+    refkey?: Refkey;
+    /**
+     * The symbol whose name becomes this part's identifier.
+     */
+    symbol?: CSharpSymbol;
+    /**
+     * The identifier to use for this part.
+     */
+    id?: string;
+    /**
+     * Create an element access part with a single indexer argument. Mutually
+     * exclusive with the `indexerArgs` prop.
+     */
+    index?: Children;
+    /**
+     * Create an element access part with multiple indexer arguments. Mutually
+     * exclusive with the `index` prop.
+     */
+    indexerArgs?: Children[];
+    /**
+     * Whether this part could possibly be null. Will guard member and element
+     * access with a conditional access operator. Passing this is not necessary if
+     * you provide a symbol or refkey and the symbol's nullable flag is set.
+     */
+    nullable?: boolean;
+}
+//# sourceMappingURL=access-expression.d.ts.map

package/dist/src/components/access-expression/access-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access-expression.d.ts","sourceRoot":"","sources":["../../../../src/components/access-expression/access-expression.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAMR,MAAM,EAGP,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAWvD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,qyCA6B5D;yBA7Be,gBAAgB;sBAoGS,yBAAyB;;AApDlE,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,EAAE,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;IAEtB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;IAEtB;;OAEG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ;;;OAGG;IACH,KAAK,CAAC,EAAE,QAAQ,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,QAAQ,EAAE,CAAC;IAEzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/dist/src/components/access-expression/access-expression.js

@@ -0,0 +1,277 @@
+import { createIntrinsic as _$createIntrinsic, createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { childrenArray, computed, For, isComponentCreator, Show, takeSymbols } from "@alloy-js/core";
+import { childrenToPartDescriptors, isArgsPart, isIdPart } from "./part-descriptors.js";
+export function AccessExpression(props) {
+  const children = flattenAccessExpression(childrenArray(() => props.children));
+  const parts = childrenToPartDescriptors(children);
+
+  // any symbols emitted from the children won't be relevant to parent scopes.
+  takeSymbols();
+  if (parts.length === 0) {
+    return [];
+  }
+  const isCallChain = computed(() => {
+    let callCount = 0;
+    for (const part of parts) {
+      if (isArgsPart(part)) callCount++;
+    }
+    return callCount > 1;
+  });
+
+  // construct a member expression from the parts. When a part is nullish,
+  // and there is a subsequent part, we use `?.` instead of `.`. accessStyle determines
+  // whether we use dot or bracket notation.
+
+  return computed(() => {
+    return isCallChain.value ? formatCallChain(parts) : formatNonCallChain(parts);
+  });
+}
+
+/**
+ * Flattens nested access expressions into a single array of parts.
+ */
+function flattenAccessExpression(children) {
+  const flattened = [];
+  for (const child of children) {
+    if (isComponentCreator(child, AccessExpression)) {
+      flattened.push(...flattenAccessExpression(childrenArray(() => child.props.children)));
+    } else {
+      flattened.push(child);
+    }
+  }
+  return flattened;
+}
+AccessExpression.Part = function (props) {
+  /** renders nothing, the parent AccessExpression will use these args */
+};
+
+/**
+ * Formatting of call chains (i.e. member expressions which have more than one
+ * call in them). The general approach is that line breaks occur after each
+ * call, and there is only one call per line. When there are non-call elements,
+ * they occur prior to the call part. The first part of the member expression
+ * contains all but the last non-call part.
+ *
+ * The following is an example of proper formatting:
+ *
+ * ```ts
+ * z.dummy             // all but the last non-call part for the first element
+ *   .object({         // the first call part with line break after
+ *      a: 1,
+ *   })
+ *   .dummy.partial()  // the next call part with non-call parts before it
+ * ```
+ */
+function formatCallChain(parts) {
+  return computed(() => {
+    const expression = [];
+
+    // break the expression into parts.
+    const chunks = [];
+
+    // the first part is all the non-call parts
+    let partIndex = 0;
+    function pushPart() {
+      const part = parts[partIndex];
+      if (!part) throw new Error("No part to push");
+      chunks.at(-1).push(part);
+      partIndex++;
+    }
+    function pushChunk() {
+      chunks.push([]);
+    }
+
+    // For the first chunk, take all the non-call parts except the last one
+    // and put them in a chunk.
+    pushChunk();
+    while (partIndex < parts.length && (partIndex === parts.length - 1 || chunks.at(-1).length === 0 || !isArgsPart(parts[partIndex + 1]))) {
+      pushPart();
+      if (isArgsPart(chunks.at(-1).at(-1))) {
+        // the first segment always ends after we see a call
+        // if we happen to take one
+        break;
+      }
+    }
+
+    // then for all remaining parts, collect all the non-call parts and end with
+    // a call chunk
+    while (partIndex < parts.length) {
+      pushChunk();
+      while (partIndex < parts.length && !isArgsPart(parts[partIndex])) {
+        pushPart();
+      }
+      while (partIndex < parts.length && isArgsPart(parts[partIndex])) {
+        pushPart();
+      }
+    }
+    for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+      const chunk = chunks[chunkIndex];
+      const chunkExpression = [];
+      for (let partIndex = 0; partIndex < chunk.length; partIndex++) {
+        if (chunkIndex === 0 && partIndex === 0) {
+          // first part is just gonna be the id
+          const firstPart = isIdPart(chunk[0]) ? chunk[0].id : chunk[0].indexerArgs;
+          chunkExpression.push(firstPart);
+          continue;
+        }
+        const part = chunk[partIndex];
+        const prevPart = partIndex === 0 ? chunks[chunkIndex - 1].at(-1) : chunk[partIndex - 1];
+        if (isArgsPart(part)) {
+          // For parts with only args (no name), append function call directly with appropriate nullish operator
+          chunkExpression.push(formatCallExpr(prevPart, part));
+        } else if (isIdPart(part)) {
+          chunkExpression.push(formatMemberAccess(prevPart, part, true));
+        } else {
+          // bracket notation - don't include the dot
+          chunkExpression.push(formatElementAccess(prevPart, part));
+        }
+      }
+      expression.push(chunkIndex === 0 ? chunkExpression : [_$createIntrinsic("sbr", {}), chunkExpression]);
+    }
+    return _$createIntrinsic("group", {
+      get children() {
+        return _$createIntrinsic("indent", {
+          children: expression
+        });
+      }
+    });
+  });
+}
+function formatNonCallChain(parts) {
+  return computed(() => {
+    const expression = [];
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const base = isIdPart(part) ? part.id : part.indexerArgs;
+      if (i === 0) {
+        expression.push(base, _$createComponent(TypeArgs, {
+          get args() {
+            return part.typeArgs;
+          }
+        }));
+      } else {
+        // Determine if we should use nullish operator from previous part
+        const prevPart = parts[i - 1];
+        if (isArgsPart(part)) {
+          // For parts with only args (no name), append function call directly with appropriate nullish operator
+          expression.push(formatCallExpr(prevPart, part));
+        } else if (isIdPart(part)) {
+          expression.push(formatMemberAccess(prevPart, part));
+        } else {
+          // bracket notation - don't include the dot
+          expression.push(formatElementAccess(prevPart, part));
+        }
+      }
+    }
+    return expression;
+  });
+}
+function formatElementAccess(prevPart, part) {
+  return _$createIntrinsic("group", {
+    get children() {
+      return [_$memo(() => part.conditional || "nullable" in prevPart && prevPart.nullable ? "?" : ""), "[", _$createIntrinsic("indent", {
+        get children() {
+          return [_$createIntrinsic("sbr", {}), _$createComponent(For, {
+            get each() {
+              return part.indexerArgs;
+            },
+            comma: true,
+            line: true,
+            children: arg => arg
+          })];
+        }
+      }), _$createIntrinsic("sbr", {}), "]"];
+    }
+  });
+}
+function formatMemberAccess(prevPart, part, noIndent = false) {
+  let Wrapping;
+  if (noIndent) {
+    Wrapping = function (props) {
+      return _$createIntrinsic("group", {
+        get children() {
+          return [_$createIntrinsic("sbr", {}), _$memo(() => props.children)];
+        }
+      });
+    };
+  } else {
+    Wrapping = function (props) {
+      return _$createIntrinsic("group", {
+        get children() {
+          return _$createIntrinsic("indent", {
+            get children() {
+              return [_$createIntrinsic("sbr", {}), _$memo(() => props.children)];
+            }
+          });
+        }
+      });
+    };
+  }
+  return _$createComponent(Wrapping, {
+    get children() {
+      return [_$memo(() => part.conditional || "nullable" in prevPart && prevPart.nullable ? "?." : "."), _$memo(() => isIdPart(part) ? part.id : part.indexerArgs), _$createComponent(TypeArgs, {
+        get args() {
+          return part.typeArgs;
+        }
+      })];
+    }
+  });
+}
+function TypeArgs(props) {
+  return _$createComponent(Show, {
+    get when() {
+      return props.args && props.args.length > 0;
+    },
+    get children() {
+      return ["<", _$createIntrinsic("group", {
+        get children() {
+          return [_$createIntrinsic("indent", {
+            get children() {
+              return [_$createIntrinsic("sbr", {}), _$createComponent(For, {
+                get each() {
+                  return props.args;
+                },
+                comma: true,
+                line: true,
+                children: arg => arg
+              })];
+            }
+          }), _$createIntrinsic("sbr", {})];
+        }
+      }), ">"];
+    }
+  });
+}
+function formatCallExpr(prevPart, part) {
+  return _$createIntrinsic("group", {
+    get children() {
+      return ["(", _$createComponent(Show, {
+        get when() {
+          return part.args.length <= 1;
+        },
+        get children() {
+          return part.args[0];
+        }
+      }), _$createComponent(Show, {
+        get when() {
+          return part.args.length > 1;
+        },
+        get children() {
+          return [_$createIntrinsic("indent", {
+            get children() {
+              return [_$createIntrinsic("sbr", {}), _$createComponent(For, {
+                get each() {
+                  return part.args;
+                },
+                comma: true,
+                line: true,
+                children: arg => arg
+              })];
+            }
+          }), _$createIntrinsic("sbr", {})];
+        }
+      }), ")"];
+    }
+  });
+}
+//# sourceMappingURL=access-expression.js.map

package/dist/src/components/access-expression/access-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["childrenArray","computed","For","isComponentCreator","Show","takeSymbols","childrenToPartDescriptors","isArgsPart","isIdPart","AccessExpression","props","children","flattenAccessExpression","parts","length","isCallChain","callCount","part","value","formatCallChain","formatNonCallChain","flattened","child","push","Part","expression","chunks","partIndex","pushPart","Error","at","pushChunk","chunkIndex","chunk","chunkExpression","firstPart","id","indexerArgs","prevPart","formatCallExpr","formatMemberAccess","formatElementAccess","_$createIntrinsic","i","base","_$createComponent","TypeArgs","args","typeArgs","_$memo","conditional","nullable","each","comma","line","arg","noIndent","Wrapping","when"],"sources":["../../../../src/components/access-expression/access-expression.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/src/components/access-expression/access-expression.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=access-expression.test.d.ts.map

package/dist/src/components/access-expression/access-expression.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access-expression.test.d.ts","sourceRoot":"","sources":["../../../../src/components/access-expression/access-expression.test.tsx"],"names":[],"mappings":""}

package/dist/src/components/access-expression/access-expression.test.js

@@ -0,0 +1,336 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { ClassDeclaration } from "#components/class/declaration.js";
+import { Method } from "#components/method/method.js";
+import { TestNamespace } from "#test/utils.js";
+import { List, namekey, printTree, renderTree } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { CSharpSymbol } from "../../symbols/csharp.js";
+import { AccessExpression } from "./access-expression.js";
+it("makes a member access expression", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      }), _$createComponent(AccessExpression.Part, {
+        id: "Bar"
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo.Bar`);
+});
+it("makes an element access expression", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      }), _$createComponent(AccessExpression.Part, {
+        index: 1
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo[1]`);
+});
+it("makes a call expression", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      }), _$createComponent(AccessExpression.Part, {
+        args: [1, 2, 3]
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo(1, 2, 3)`);
+});
+it("makes an id part from a symbol", () => {
+  const symbol = new CSharpSymbol("Symbol", undefined);
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      }), _$createComponent(AccessExpression.Part, {
+        symbol: symbol
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo.Symbol`);
+});
+it("makes an id part from a symbol reactively", () => {
+  const symbol = new CSharpSymbol("Symbol", undefined);
+  const tree = renderTree(_$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      }), _$createComponent(AccessExpression.Part, {
+        symbol: symbol
+      })];
+    }
+  }));
+  expect(printTree(tree)).toEqual("Foo.Symbol");
+  symbol.name = "Bar";
+  expect(printTree(tree)).toEqual("Foo.Bar");
+});
+it("makes an id part from refkey, where the first part is a full reference, and subsequent parts are just the id", () => {
+  const methodKey = namekey("method");
+  const template = _$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(List, {
+        get children() {
+          return [_$createComponent(ClassDeclaration, {
+            name: "MyClass",
+            get children() {
+              return _$createComponent(Method, {
+                name: methodKey
+              });
+            }
+          }), _$createComponent(AccessExpression, {
+            get children() {
+              return [_$createComponent(AccessExpression.Part, {
+                refkey: methodKey
+              }), _$createComponent(AccessExpression.Part, {
+                refkey: methodKey
+              })];
+            }
+          })];
+        }
+      });
+    }
+  });
+  expect(template).toRenderTo(`
+    class MyClass
+    {
+        void Method() {}
+    }
+    MyClass.Method.Method
+  `);
+});
+it("takes type args", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return _$createComponent(AccessExpression.Part, {
+        id: "Foo",
+        typeArgs: ["Foo", "Bar"]
+      });
+    }
+  });
+  expect(template).toRenderTo(`Foo<Foo, Bar>`);
+});
+it("takes multiple indexer arguments", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      }), _$createComponent(AccessExpression.Part, {
+        indexerArgs: ["arg1", "arg2"]
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo[arg1, arg2]`);
+});
+it("allows nullable member access", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo",
+        nullable: true
+      }), _$createComponent(AccessExpression.Part, {
+        id: "Bar"
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo?.Bar`);
+});
+it("allows conditional member access", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      }), _$createComponent(AccessExpression.Part, {
+        id: "Bar",
+        conditional: true
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo?.Bar`);
+});
+it("allows nullable element access", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo",
+        nullable: true
+      }), _$createComponent(AccessExpression.Part, {
+        index: 1
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo?[1]`);
+});
+it("allows conditional element access", () => {
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      }), _$createComponent(AccessExpression.Part, {
+        index: 1,
+        conditional: true
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Foo?[1]`);
+});
+it("uses symbol information for nullability", () => {
+  const symbol = new CSharpSymbol("Symbol", undefined, {
+    isNullable: true
+  });
+  const typeSymbol = new CSharpSymbol("SomeType", undefined, {
+    isNullable: true
+  });
+  const typedSymbol = new CSharpSymbol("SomeValue", undefined, {
+    type: typeSymbol
+  });
+  const template = _$createComponent(AccessExpression, {
+    get children() {
+      return [_$createComponent(AccessExpression.Part, {
+        symbol: symbol
+      }), _$createComponent(AccessExpression.Part, {
+        symbol: typedSymbol
+      }), _$createComponent(AccessExpression.Part, {
+        id: "Foo"
+      })];
+    }
+  });
+  expect(template).toRenderTo(`Symbol?.SomeValue?.Foo`);
+});
+describe("formatting", () => {
+  it("breaks long identifier chains", () => {
+    const template = _$createComponent(AccessExpression, {
+      get children() {
+        return [_$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        })];
+      }
+    });
+    expect(template).toRenderTo(`
+      Foo.Foo
+        .Foo.Foo
+        .Foo.Foo
+      `, {
+      printWidth: 10
+    });
+  });
+  it("breaks long call expressions", () => {
+    const template = _$createComponent(AccessExpression, {
+      get children() {
+        return [_$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Bar"
+        }), _$createComponent(AccessExpression.Part, {
+          args: ["variable1", "variable2", "variable3"]
+        })];
+      }
+    });
+    expect(template).toRenderTo(`
+      Foo.Bar(
+        variable1,
+        variable2,
+        variable3
+      )
+      `, {
+      printWidth: 10
+    });
+  });
+  it("breaks long type args", () => {
+    const template = _$createComponent(AccessExpression, {
+      get children() {
+        return _$createComponent(AccessExpression.Part, {
+          id: "Foo",
+          typeArgs: ["Foo", "Bar", "Baz", "Qux"]
+        });
+      }
+    });
+    expect(template).toRenderTo(`
+      Foo<
+        Foo,
+        Bar,
+        Baz,
+        Qux
+      >
+      `, {
+      printWidth: 10
+    });
+  });
+  it("breaks long type args for second member", () => {
+    const template = _$createComponent(AccessExpression, {
+      get children() {
+        return [_$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Bar",
+          typeArgs: ["Foo", "Bar", "Baz", "Qux"]
+        })];
+      }
+    });
+    expect(template).toRenderTo(`
+      Foo
+        .Bar<
+          Foo,
+          Bar,
+          Baz,
+          Qux
+        >
+      `, {
+      printWidth: 10
+    });
+  });
+  it("formats builder pattern", () => {
+    const template = _$createComponent(AccessExpression, {
+      get children() {
+        return [_$createComponent(AccessExpression.Part, {
+          id: "Foo"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Bar"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Baz"
+        }), _$createComponent(AccessExpression.Part, {
+          args: true
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Qux"
+        }), _$createComponent(AccessExpression.Part, {
+          id: "Quux",
+          typeArgs: ["TTypeOne", "TTypeTwo"]
+        }), _$createComponent(AccessExpression.Part, {
+          indexerArgs: ["arg1", "arg2"]
+        }), _$createComponent(AccessExpression.Part, {
+          args: true
+        })];
+      }
+    });
+    expect(template).toRenderTo(`
+        Foo.Bar
+          .Baz()
+          .Qux
+          .Quux<
+            TTypeOne,
+            TTypeTwo
+          >[
+            arg1,
+            arg2
+          ]()
+      `, {
+      printWidth: 10
+    });
+  });
+});
+//# sourceMappingURL=access-expression.test.js.map