tla-ts 0.0.2 → 0.0.3-dev.a50fc89

package/src/parser.ts

@@ -153,6 +153,8 @@ const EXPRESSION_PREFIXES = new Set([
   "<>",
 ]);
 
+const CIRCLED_OPERATORS = new Set(["+", "-", "/", "\\X"]);
+
 const OPERATOR_ARGUMENTS = new Set([
   "SUBSET",
   "UNION",
@@ -213,6 +215,41 @@ const PROOF_STARTS = new Set(["BY", "PROOF", "OBVIOUS", "OMITTED"]);
 
 const PROVABLE_STEPS = new Set(["Qed", "Pick", "Case", "Assert"]);
 
+const TLAPM_PUNCTUATION = new Set([
+  ",",
+  ".",
+  "_",
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  "<<",
+  ">>",
+  "]_",
+  ">>_",
+  "==",
+  "!",
+  "@",
+  ":",
+  "::",
+  ";",
+  "->",
+  "<-",
+  "|->",
+  "\\A",
+  "\\AA",
+  "\\E",
+  "\\EE",
+  "\\forall",
+  "\\exists",
+  "WF_",
+  "SF_",
+  "(*{",
+  "}*)",
+]);
+
 const UNNAMED_STEP_LABELS = new Set(["", "*", "-"]);
 
 const FACT_KEYWORDS = new Set([
@@ -264,7 +301,9 @@ export const extractModule = (source: string, name: string) => {
   return lines.slice(start, end === -1 ? undefined : end + 1).join("\n");
 };
 
-export const parseModule = (source: string): Module => {
+// isTlapm parses as tlapm does for proof obligations, which accepts and rejects some modules that
+// SANY does not.
+const parse = (source: string, isTlapm: boolean): Module => {
   const tokens = tokenize(source);
   const cursor = { index: 0, offsideColumns: [] as number[] };
   // A RECURSIVE declaration covers the definitions of its own LET or module.
@@ -280,7 +319,7 @@ export const parseModule = (source: string): Module => {
 
   const getLocation = (token: Token): SourceLocation => ({
     line: token.line,
-    column: token.column,
+    column: isTlapm && token.kind === "String" ? token.endColumn : token.column,
     range: undefined,
   });
 
@@ -324,10 +363,78 @@ export const parseModule = (source: string): Module => {
   const describe = (token: Token) =>
     token.kind === "End" ? "end of input" : JSON.stringify(token.text);
 
-  const createError = (message: string, token: { line: number; column: number } = peekRaw()) =>
-    new TlaSyntaxError(`${message} at line ${token.line}, column ${token.column}`);
+  const unitStart = { index: 0 };
+
+  const getDefinitionEnd = (fallback: { line: number; column: number }) => {
+    const equals = tokens
+      .slice(unitStart.index, cursor.index)
+      .find((token) => token.text === "==" && token.kind !== "String");
+    return equals ? { line: equals.line, column: equals.endColumn + 1 } : fallback;
+  };
+
+  // tlapm reads TRUE, FALSE, BOOLEAN, STRING and the other keywords only as keywords.
+  const isTlapmKeyword = (token: Token) =>
+    isTlapm && (token.kind === "Keyword" || BUILTIN_CONSTANTS.has(token.text));
 
-  const isFieldName = (token: Token) => token.kind === "Identifier" || token.kind === "Keyword";
+  const getPreviousEnd = (position: { line: number; column: number }) => {
+    const previous = tokens.findLast(
+      (token) =>
+        token.kind !== "End" &&
+        (token.line < position.line ||
+          (token.line === position.line && token.column < position.column)),
+    );
+    return previous ? { line: previous.line, column: previous.endColumn + 1 } : position;
+  };
+
+  const getTlapmName = (token: Token) => {
+    if (/^-{4,}$/.test(token.text)) return "----";
+    if (/^={4,}$/.test(token.text)) return "====";
+    if (TLAPM_PUNCTUATION.has(token.text) || token.kind === "Number" || token.kind === "Decimal")
+      return token.text;
+    if (token.kind === "String") return JSON.stringify(token.text);
+    if (isTlapmKeyword(token)) return `keyword ${token.text}`;
+    return token.kind === "Identifier" ? `identifier ${token.text}` : `operator ${token.text}`;
+  };
+
+  const createError = (
+    message: string,
+    token: { line: number; column: number } = peekRaw(),
+    unexpected?: Token,
+  ) => {
+    const end = tokens[tokens.length - 1];
+    const isEnd = token.line === end.line && token.column === end.column;
+    return new TlaSyntaxError(
+      `${message} at line ${token.line}, column ${token.column}`,
+      undefined,
+      getFailure(message, token, isEnd, unexpected),
+    );
+  };
+
+  const getFailure = (
+    message: string,
+    token: { line: number; column: number },
+    isEnd: boolean,
+    unexpected: Token | undefined,
+  ) => {
+    if (isTlapm && isEnd) {
+      const end = tokens[tokens.length - 1];
+      return { reason: "Unexpected EOF", ...getDefinitionEnd(getPreviousEnd(end)), isEnd };
+    }
+    if (isTlapm && unexpected) {
+      return {
+        reason: `Unexpected ${getTlapmName(unexpected)}`,
+        ...getPreviousEnd(unexpected),
+        isEnd,
+      };
+    }
+    return { reason: message, line: token.line, column: token.column, isEnd };
+  };
+
+  const createUnexpected = (message: string, token: Token = peekRaw()) =>
+    createError(message, token, token);
+
+  const isFieldName = (token: Token) =>
+    (token.kind === "Identifier" || token.kind === "Keyword") && !isTlapmKeyword(token);
 
   const isAt = (text: string, offset = 0) => {
     const token = peek(offset);
@@ -349,15 +456,16 @@ export const parseModule = (source: string): Module => {
 
   const expect = (text: string) => {
     if (!isAt(text))
-      throw createError(`Expected ${JSON.stringify(text)} but found ${describe(peek())}`);
+      throw createUnexpected(`Expected ${JSON.stringify(text)} but found ${describe(peek())}`);
     return advance();
   };
 
   const expectIdentifier = () => {
     const token = peek();
     if (token.kind !== "Identifier") {
-      throw createError(`Expected an identifier but found ${describe(token)}`);
+      throw createUnexpected(`Expected an identifier but found ${describe(token)}`);
     }
+    if (isTlapmKeyword(token)) throw createUnexpected(`Unexpected keyword ${token.text}`);
     cursor.index++;
     return token.text;
   };
@@ -422,7 +530,7 @@ export const parseModule = (source: string): Module => {
     const token = peek();
     if (token.kind === "Identifier") {
       const start = cursor.index;
-      const names = [expectIdentifier()];
+      const names = [advance().text];
       while (isAt("!") && peek(1).kind === "Identifier") {
         advance();
         names.push(expectIdentifier());
@@ -433,7 +541,7 @@ export const parseModule = (source: string): Module => {
       );
     }
     if (isAt("<<") || isAt("(")) return parsePrimary();
-    throw createError(`Expected a subscript but found ${describe(token)}`);
+    throw createUnexpected(`Expected a subscript but found ${describe(token)}`);
   };
 
   const isDefinitionAhead = (operator: Token) => {
@@ -470,6 +578,23 @@ export const parseModule = (source: string): Module => {
       token.kind === "Operator" &&
       (INFIX_OPERATORS.has(token.text) || PREFIX_OPERATOR_REFERENCES.has(token.text)) &&
       isStandalone(token);
+    // tlapm reads a prefix operator as the start of an expression, and (+), (-), (/) and (\X) as
+    // the operators \oplus, \ominus, \oslash and \otimes.
+    const isTlapmIncomplete =
+      isTlapm &&
+      token.kind !== "String" &&
+      (PREFIX_OPERATOR_REFERENCES.has(token.text) ||
+        (OPERATOR_ARGUMENTS.has(token.text) &&
+          token.text !== "'" &&
+          !POSTFIX_OPERATORS.has(token.text)) ||
+        (CIRCLED_OPERATORS.has(token.text) &&
+          peek(-1).text === "(" &&
+          peek(-1).line === token.line &&
+          peek(-1).endColumn + 1 === token.column &&
+          peek(1).text === ")" &&
+          peek(1).line === token.line &&
+          peek(1).column === token.endColumn + 1));
+    if (isTlapmIncomplete && isStandalone(token)) throw createError("incomplete expression", token);
     if (isOperatorAlone) {
       cursor.index++;
       return withRange(
@@ -524,6 +649,7 @@ export const parseModule = (source: string): Module => {
     return {
       kind: bullet.text === "/\\" ? "And" : "Or",
       operands,
+      isBulleted: true,
       location: getLocation(bullet),
     };
   };
@@ -561,7 +687,7 @@ export const parseModule = (source: string): Module => {
           while (isAt(".") || isAt("[")) {
             if (accept(".")) {
               if (!isFieldName(peek()))
-                throw createError(`Expected a field name but found ${describe(peek())}`);
+                throw createUnexpected(`Expected a field name but found ${describe(peek())}`);
               path.push({ kind: "Field", name: advance().text });
               continue;
             }
@@ -637,7 +763,14 @@ export const parseModule = (source: string): Module => {
     }
     const names = parseSeparated(expectIdentifier);
     expect(":");
-    return { kind: "UnboundedQuantifier", names, body: parseExpression(), isTemporal, location };
+    return {
+      kind: "UnboundedQuantifier",
+      quantifier: start.text === "\\A" || start.text === "\\AA" ? "Forall" : "Exists",
+      names,
+      body: parseExpression(),
+      isTemporal,
+      location,
+    };
   };
 
   const parseCase = (start: Token): Expression => {
@@ -691,7 +824,13 @@ export const parseModule = (source: string): Module => {
     const isFactStart = cursor.index === factStart.index;
     const token = advance();
     const location = getLocation(token);
+    if (isTlapm && token.kind === "Keyword" && token.text === "LAMBDA") {
+      const params = parseSeparated(expectIdentifier);
+      expect(":");
+      return { kind: "Lambda", params, body: parseExpression(), location };
+    }
     if (token.kind === "Number") {
+      if (isTlapm && /^\\[BOH]/.test(token.text)) throw createError("incomplete expression", token);
       return { kind: "Number", value: getNumeralValue(token.text), text: token.text, location };
     }
     if (token.kind === "Decimal") return { kind: "Decimal", text: token.text, location };
@@ -721,7 +860,7 @@ export const parseModule = (source: string): Module => {
       const instance = openModules
         .flatMap((module) => module.instances)
         .find((candidate) => candidate.name === name);
-      if (instance && !isFactStart && instance.params.length !== args.length) {
+      if (instance && !isFactStart && !isTlapm && instance.params.length !== args.length) {
         throw createError(
           `The operator ${name} requires ${instance.params.length} arguments`,
           token,
@@ -740,9 +879,13 @@ export const parseModule = (source: string): Module => {
       const qualifiedArgs = selectors.flatMap((selector) =>
         "args" in selector ? selector.args : [],
       );
-      return qualifiedArgs.length > 0
-        ? { kind: "Apply", operator, args: qualifiedArgs, location }
-        : { kind: "Identifier", name: operator, location };
+      if (qualifiedArgs.length === 0) return { kind: "Identifier", name: operator, location };
+      const argumentCounts = selectors.map((selector) =>
+        "args" in selector ? selector.args.length : 0,
+      );
+      return argumentCounts.slice(0, -1).some((count) => count > 0)
+        ? { kind: "Apply", operator, args: qualifiedArgs, argumentCounts, location }
+        : { kind: "Apply", operator, args: qualifiedArgs, location };
     }
     if (token.kind === "Operator" && isOperatorName(token.text) && isAt("("))
       return { kind: "Apply", operator: token.text, args: parseArguments(), location };
@@ -779,6 +922,8 @@ export const parseModule = (source: string): Module => {
         const instances: Instance[] = [];
         recursiveScopes.push(new Set());
         while (!accept("IN")) {
+          if (isTlapm && isAt("RECURSIVE"))
+            throw createError("Unexpected keyword RECURSIVE", getDefinitionEnd(peekRaw()));
           if (accept("RECURSIVE")) {
             declareRecursive();
             continue;
@@ -816,7 +961,7 @@ export const parseModule = (source: string): Module => {
         };
       }
     }
-    throw createError(`Unexpected ${describe(token)}`, token);
+    throw createUnexpected(`Unexpected ${describe(token)}`, token);
   };
 
   const parsePrefix = (): Expression => {
@@ -1004,9 +1149,13 @@ export const parseModule = (source: string): Module => {
         location,
       };
     }
+    const definitionStart = cursor.index;
     const params = parseParams();
     expect("==");
-    if (isAt("INSTANCE")) return parseInstance(name, params, isLocal, location);
+    if (isAt("INSTANCE")) {
+      const instance = parseInstance(name, params, isLocal, location);
+      return { ...instance, definitionRange: getRange(definitionStart) };
+    }
     return parseOperator(name, params);
   };
 
@@ -1016,6 +1165,7 @@ export const parseModule = (source: string): Module => {
     isLocal: boolean,
     location: SourceLocation,
   ): Instance => {
+    const start = cursor.index;
     expect("INSTANCE");
     const module = expectIdentifier();
     const substitutions = accept("WITH")
@@ -1025,7 +1175,16 @@ export const parseModule = (source: string): Module => {
           return { name: target, expression: parseArgument() };
         })
       : [];
-    return { kind: "Instance", name, params, module, substitutions, isLocal, location };
+    return {
+      kind: "Instance",
+      name,
+      params,
+      module,
+      substitutions,
+      isLocal,
+      location,
+      instanceRange: getRange(start),
+    };
   };
 
   const parseDeclaration = (): Declaration => {
@@ -1049,10 +1208,13 @@ export const parseModule = (source: string): Module => {
 
   const parseDeclarations = () => parseSeparated(parseDeclaration);
 
-  const declareRecursive = () =>
-    parseDeclarations().forEach((declaration) =>
+  const declareRecursive = () => {
+    const declarations = parseDeclarations();
+    declarations.forEach((declaration) =>
       recursiveScopes[recursiveScopes.length - 1].add(declaration.name),
     );
+    return declarations;
+  };
 
   const getClosingOffset = (offset: number) => {
     const depth = { value: 0, offset };
@@ -1200,7 +1362,30 @@ export const parseModule = (source: string): Module => {
         module.variables.some((variable) => variable.name === name),
     );
 
+  // tlapm's definable: names and operators joined by !.
+  const parseDefinable = (): Fact => {
+    const start = cursor.index;
+    const token = peek();
+    const parts = parseSeparated(() => {
+      const part = peek();
+      const isName = part.kind === "Identifier" && !isTlapmKeyword(part);
+      if (!isName && part.kind !== "Operator") {
+        throw createUnexpected(`Expected a definition name but found ${describe(part)}`, part);
+      }
+      cursor.index++;
+      return part.text;
+    }, "!");
+    const location = getLocation(token);
+    return withRange(
+      parts.length === 1 && token.kind === "Operator"
+        ? { kind: "OperatorReference", operator: token.text, location }
+        : { kind: "Identifier", name: parts.join("!"), location },
+      start,
+    );
+  };
+
   const parseDefs = () => {
+    if (isTlapm) return parseSeparated(parseDefinable);
     const defs = parseSeparated(parseFact);
     const invalid = defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name));
     if (invalid) {
@@ -1218,13 +1403,16 @@ export const parseModule = (source: string): Module => {
     const start = cursor.index;
     const keyword = advance();
     const isOnly = keyword.text === "USE" && accept("ONLY");
+    const keywordRange = getRange(start);
     const use: UseOrHide = {
       kind: keyword.text === "USE" ? "Use" : "Hide",
       isOnly,
       ...parseFacts(),
+      keyword: keywordRange,
       location: getLocation(keyword),
     };
-    const invalid = use.kind === "Hide" ? use.facts.find((fact) => !isHideFact(fact)) : undefined;
+    const invalid =
+      use.kind === "Hide" && !isTlapm ? use.facts.find((fact) => !isHideFact(fact)) : undefined;
     if (invalid) {
       throw createError(
         "The only expression allowed as a fact in a HIDE is the name of a theorem, assumption, or step",
@@ -1240,7 +1428,7 @@ export const parseModule = (source: string): Module => {
     const isNew = accept("NEW");
     const level = peek().kind === "Keyword" ? NEW_SYMBOL_LEVELS.get(peek().text) : undefined;
     if (!isNew && level === undefined) {
-      throw createError(`Expected a declaration but found ${describe(peek())}`);
+      throw createUnexpected(`Expected a declaration but found ${describe(peek())}`);
     }
     if (level !== undefined) advance();
     if (level === "Variable") {
@@ -1347,7 +1535,7 @@ export const parseModule = (source: string): Module => {
   const parseStepStart = (isQed: boolean) => {
     const step = peek();
     if (step.kind !== "Step") {
-      throw createError(`Expected a step number but found ${describe(step)}`);
+      throw createUnexpected(`Expected a step number but found ${describe(step)}`, step);
     }
     if (!isCorrectLevel(step)) {
       throw createError(`${isQed ? "QED step" : "step"}'s number has bad level`, step);
@@ -1356,7 +1544,7 @@ export const parseModule = (source: string): Module => {
       throw createError("<*> and <+> cannot be used for a named step", step);
     }
     cursor.index++;
-    return { name: getStepName(step), location: getLocation(step) };
+    return { name: getStepName(step), token: step.text, location: getLocation(step) };
   };
 
   // The names an assertion assumes stay in its own proof, and other steps declare theirs for the rest
@@ -1367,6 +1555,7 @@ export const parseModule = (source: string): Module => {
     const scope = new Set<string>();
     proofScopes.push(scope);
     const body: StepBody = accept("QED") ? { kind: "Qed" } : parseStepBody();
+    const head = getRange(start);
     const hasProof = isProofStart(peek());
     if (hasProof && !PROVABLE_STEPS.has(body.kind)) {
       throw createError("Proof of a step that does not take a proof");
@@ -1374,7 +1563,7 @@ export const parseModule = (source: string): Module => {
     const proof = hasProof ? parseProof() : undefined;
     proofScopes.pop();
     if (body.kind !== "Assert" || body.isSuffices) scope.forEach(declareProofSymbol);
-    return withRange({ ...step, body, proof }, start);
+    return withRange({ ...step, body, head, proof }, start);
   };
 
   const parseProofBody = (): Proof => {
@@ -1382,7 +1571,8 @@ export const parseModule = (source: string): Module => {
     if (isAt("BY") || (isAt("PROOF") && isAt("BY", 1))) {
       accept("PROOF");
       advance();
-      return { kind: "By", isOnly: accept("ONLY"), ...parseFacts(), location };
+      const keyword = getRange(cursor.index - 1);
+      return { kind: "By", isOnly: accept("ONLY"), ...parseFacts(), keyword, location };
     }
     const terminal = peek(isAt("PROOF") ? 1 : 0);
     if (
@@ -1391,7 +1581,8 @@ export const parseModule = (source: string): Module => {
     ) {
       accept("PROOF");
       advance();
-      return { kind: terminal.text === "OBVIOUS" ? "Obvious" : "Omitted", location };
+      const keyword = getRange(cursor.index - 1);
+      return { kind: terminal.text === "OBVIOUS" ? "Obvious" : "Omitted", keyword, location };
     }
     accept("PROOF");
     const steps = [parseStep()];
@@ -1421,9 +1612,12 @@ export const parseModule = (source: string): Module => {
       return { statement, proof: isProofStart(peek()) ? parseProof() : undefined };
     });
     const statement = parsed.statement;
-    module.theorems.push(
-      withRange({ name, statement, proof: parsed.proof, location: getLocation(keyword) }, start),
+    const theorem = withRange(
+      { name, statement, proof: parsed.proof, location: getLocation(keyword) },
+      start,
     );
+    module.theorems.push(theorem);
+    module.units.push({ kind: "Theorem", theorem });
     if (name === undefined || statement.kind === "AssumeProve") return;
     module.definitions.push(
       withRange(
@@ -1467,7 +1661,8 @@ export const parseModule = (source: string): Module => {
     const module: Module = {
       name,
       modules: [],
-      extends: accept("EXTENDS") ? parseSeparated(expectIdentifier) : [],
+      extends: [],
+      extendsRanges: [],
       constants: [],
       variables: [],
       definitions: [],
@@ -1476,20 +1671,38 @@ export const parseModule = (source: string): Module => {
       location,
       theorems: [],
       uses: [],
+      units: [],
     };
     openModules.push(module);
     recursiveScopes.push(new Set());
+    if (accept("EXTENDS")) {
+      parseSeparated(() => {
+        const start = cursor.index;
+        module.extends.push(expectIdentifier());
+        module.extendsRanges.push(getRange(start));
+      });
+    }
     while (true) {
       const tokenIndex = cursor.index;
+      unitStart.index = tokenIndex;
       const token = peek();
       if (token.kind === "ModuleEnd" || token.kind === "End") {
+        if (token.kind === "ModuleEnd") {
+          location.range = {
+            module: name,
+            start: { line: location.line, column: location.column },
+            end: { line: token.line, column: token.endColumn },
+          };
+        }
         openModules.pop();
         recursiveScopes.pop();
         return module;
       }
       if (token.kind === "Separator") {
         if (isAt("MODULE", 1)) {
-          module.modules.push(parseModuleBody());
+          const submodule = parseModuleBody();
+          module.modules.push(submodule);
+          module.units.push({ kind: "Module", module: submodule });
           expect("====");
           continue;
         }
@@ -1498,26 +1711,31 @@ export const parseModule = (source: string): Module => {
       }
       switch (token.text) {
         case "CONSTANT":
-        case "CONSTANTS":
+        case "CONSTANTS": {
           advance();
-          module.constants.push(...parseDeclarations());
+          const declarations = parseDeclarations();
+          module.constants.push(...declarations);
+          module.units.push({ kind: "Constants", declarations });
           continue;
+        }
         case "VARIABLE":
-        case "VARIABLES":
+        case "VARIABLES": {
           advance();
-          module.variables.push(
-            ...parseSeparated(() => {
-              const start = cursor.index;
-              const location = getLocation(peek());
-              return withRange({ name: expectIdentifier(), arity: 0, location }, start);
-            }),
-          );
+          const declarations = parseSeparated(() => {
+            const start = cursor.index;
+            const location = getLocation(peek());
+            return withRange({ name: expectIdentifier(), arity: 0, location }, start);
+          });
+          module.variables.push(...declarations);
+          module.units.push({ kind: "Variables", declarations });
           continue;
+        }
         case "ASSUME":
         case "ASSUMPTION":
         case "AXIOM": {
           const assumption = parseAssumption();
           module.assumptions.push(assumption);
+          module.units.push({ kind: "Assumption", assumption });
           if (assumption.name !== undefined) {
             module.definitions.push({
               kind: "Operator",
@@ -1532,29 +1750,32 @@ export const parseModule = (source: string): Module => {
           continue;
         }
         case "USE":
-        case "HIDE":
-          module.uses.push(parseUseOrHide());
+        case "HIDE": {
+          const use = parseUseOrHide();
+          module.uses.push(use);
+          module.units.push({ kind: "Use", use });
           continue;
+        }
         case "RECURSIVE":
           advance();
-          declareRecursive();
+          module.units.push({ kind: "Recursive", declarations: declareRecursive() });
           continue;
         case "INSTANCE":
-          module.instances.push(
+          addDefinitionUnit(
+            module,
             withRange(parseInstance(undefined, [], false, getLocation(token)), tokenIndex),
           );
           continue;
         case "LOCAL": {
           advance();
           if (isAt("INSTANCE")) {
-            module.instances.push(
+            addDefinitionUnit(
+              module,
               withRange(parseInstance(undefined, [], true, getLocation(token)), tokenIndex),
             );
             continue;
           }
-          const unit = parseDefinition(true);
-          if (unit.kind === "Instance") module.instances.push(unit);
-          else module.definitions.push(unit);
+          addDefinitionUnit(module, parseDefinition(true));
           continue;
         }
       }
@@ -1562,11 +1783,23 @@ export const parseModule = (source: string): Module => {
         parseTheorem(module);
         continue;
       }
-      const unit = parseDefinition(false);
-      if (unit.kind === "Instance") module.instances.push(unit);
-      else module.definitions.push(unit);
+      addDefinitionUnit(module, parseDefinition(false));
     }
   };
 
+  const addDefinitionUnit = (module: Module, unit: Definition | Instance) => {
+    if (unit.kind === "Instance") {
+      module.instances.push(unit);
+      module.units.push({ kind: "Instance", instance: unit });
+      return;
+    }
+    module.definitions.push(unit);
+    module.units.push({ kind: "Definition", definition: unit });
+  };
+
   return parseModuleBody();
 };
+
+export const parseModule = (source: string) => parse(source, false);
+
+export const parseTlapmModule = (source: string) => parse(source, true);