hermes-transform 0.5.0 → 0.8.0

package/dist/transform/comments/comments.js

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.CommentPlacement = void 0;
+exports.addComment = addComment;
 exports.addCommentsToNode = addCommentsToNode;
-exports.addLeadingComment = addLeadingComment;
-exports.addTrailingComment = addTrailingComment;
 exports.appendCommentToSource = appendCommentToSource;
 exports.attachComments = attachComments;
 exports.cloneComment = cloneComment;
@@ -24,25 +24,31 @@ var _printerEstree = _interopRequireDefault(require("./prettier/language-js/prin
 
 var _util = require("./prettier/common/util");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var _os = require("os");
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// $FlowExpectedError[untyped-import]
+// $FlowExpectedError[untyped-import]
+// $FlowExpectedError[untyped-import]
+const CommentPlacement = require("flow-enums-runtime").Mirrored(["LEADING_OWN_LINE", "LEADING_INLINE", "TRAILING_OWN_LINE", "TRAILING_INLINE"]);
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+exports.CommentPlacement = CommentPlacement;
 
 function attachComments(comments, ast, text) {
   (0, _comments.attach)(comments, ast, text, {
     locStart: _loc.locStart,
     locEnd: _loc.locEnd,
-    printer: _printerEstree["default"]
+    printer: _printerEstree.default
   });
 }
 
@@ -57,19 +63,19 @@ function setCommentsOnNode(node, comments) {
 }
 
 function addCommentsToNode(node, comments) {
-  var _node$comments, _ref;
+  var _node$comments;
 
   // $FlowExpectedError - this property is secretly added by prettier.
-  node.comments = (_node$comments = node.comments) !== null && _node$comments !== void 0 ? _node$comments : []; // $FlowExpectedError
+  node.comments = (_node$comments = node.comments) != null ? _node$comments : []; // $FlowExpectedError
 
-  (_ref = node.comments).push.apply(_ref, _toConsumableArray(comments));
+  node.comments.push(...comments);
 }
 
 function getCommentsForNode(node) {
   var _node$comments2;
 
   // $FlowExpectedError - this property is secretly added by prettier.
-  return (_node$comments2 = node.comments) !== null && _node$comments2 !== void 0 ? _node$comments2 : [];
+  return (_node$comments2 = node.comments) != null ? _node$comments2 : [];
 }
 
 function isLeadingComment(comment) {
@@ -82,12 +88,22 @@ function isTrailingComment(comment) {
   return comment.trailing === true;
 }
 
-function addLeadingComment(node, comment) {
-  (0, _util.addLeadingComment)(node, comment);
-}
-
-function addTrailingComment(node, comment) {
-  (0, _util.addTrailingComment)(node, comment);
+function addComment(node, comment, placement) {
+  switch (placement) {
+    case CommentPlacement.LEADING_OWN_LINE:
+    case CommentPlacement.LEADING_INLINE:
+      {
+        (0, _util.addLeadingComment)(node, comment);
+        break;
+      }
+
+    case CommentPlacement.TRAILING_OWN_LINE:
+    case CommentPlacement.TRAILING_INLINE:
+      {
+        (0, _util.addTrailingComment)(node, comment);
+        break;
+      }
+  }
 }
 
 function cloneComment(comment) {
@@ -112,29 +128,100 @@ function cloneCommentWithMarkers(comment) {
   };
 }
 
-function appendCommentToSource(code, comment) {
-  // prettier slices comments directly from the source code when printing
-  // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
-  // this means that we need to have any appended comments directly in the
-  // source code or else prettier will slice nothing and bork up the transform
-  var commentText = comment.value;
+function getFirstNewlineIndex(code) {
+  return code.search(/\r\n|\n|\r/);
+}
+
+function getFirstNonWhitespaceIndex(code) {
+  return code.search(/\S/);
+}
+
+function appendCommentToSource(code, comment, placement) {
+  let newCode = code;
 
   switch (comment.type) {
     case 'Block':
-      commentText = "/*".concat(commentText, "*/");
-      break;
+      {
+        // Prettier decides if a newline is necessary between the comment and its node by looking
+        // to see if a newline seperates them in the source text. We can trick prettier into
+        // formatting how we want for new comments by placing the range such that a newline
+        // will (OWN_LINE) or will not (INLINE) be found when searching from the specified range
+        // position.
+        switch (placement) {
+          case CommentPlacement.LEADING_OWN_LINE:
+          case CommentPlacement.TRAILING_OWN_LINE:
+            {
+              // Since we always want a line break we need to ensure a newline is found when
+              // searching out from either side of the comment range.
+              let firstNewline = getFirstNewlineIndex(code);
+
+              if (firstNewline === -1) {
+                // No newline in file, lets add one.
+                newCode += _os.EOL;
+                firstNewline = newCode.length;
+              } // Prettier only uses these ranges for detecting whitespace, so this nonsensical
+              // range is safe.
+              // $FlowExpectedError[cannot-write]
+
+
+              comment.range = [firstNewline + 1, firstNewline];
+              break;
+            }
+
+          case CommentPlacement.LEADING_INLINE:
+          case CommentPlacement.TRAILING_INLINE:
+            {
+              // Since we don't want a line break we need to ensure a non whitespace char is
+              // always found before a newline when searching out from either side of the
+              // comment range.
+              let firstNonWhitespace = getFirstNonWhitespaceIndex(code);
+
+              if (firstNonWhitespace === -1) {
+                // No non whitespace chars in file, lets add an identifiable statement for prettier to find.
+                newCode += '$FORCE_INLINE_ON_EMPTY_FILE_TOKEN$;';
+                firstNonWhitespace = newCode.length;
+                break;
+              } // $FlowExpectedError[cannot-write]
+
+
+              comment.range = [firstNonWhitespace + 1, firstNonWhitespace];
+              break;
+            }
+        }
+
+        break;
+      }
 
     case 'Line':
-      commentText = "//".concat(commentText);
-      break;
+      {
+        // For `Line` comments prettier slices comments directly from the source code when printing
+        // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
+        // this means that we need to have any appended comments directly in the
+        // source code or else prettier will slice nothing and bork up the transform
+        const commentText = `//${comment.value}`;
+        const lastChar = newCode[newCode.length - 1];
+
+        if (lastChar !== '\n' && lastChar !== '\r') {
+          newCode += _os.EOL;
+        } // Line comments cannot be inline before a node so we only place trailing Line comments inline.
+
+
+        if (placement === CommentPlacement.TRAILING_INLINE) {
+          // Prettier determines an "end of line" comment by walking backwards from
+          // the comment start range through the source code to see if it finds a non
+          // newline token. In order to trick prettier for new comments we need to
+          // insert fake source code for it to find.
+          newCode += '$FORCE_END_OF_LINE_COMMENT_TOKEN$;';
+        }
+
+        const start = newCode.length;
+        newCode += commentText;
+        const end = newCode.length; // $FlowExpectedError[cannot-write]
+
+        comment.range = [start, end];
+        break;
+      }
   }
 
-  var newCode = code;
-  newCode += '\n';
-  var start = newCode.length;
-  newCode += commentText;
-  var end = newCode.length; // $FlowExpectedError[cannot-write]
-
-  comment.range = [start, end];
   return newCode;
 }

package/dist/transform/comments/comments.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -23,9 +23,17 @@ import {
   // $FlowExpectedError[untyped-import]
   addTrailingComment as untypedAddTrailingComment,
 } from './prettier/common/util';
+import {EOL} from 'os';
 
 export type Options = $ReadOnly<{}>;
 
+export enum CommentPlacement {
+  LEADING_OWN_LINE,
+  LEADING_INLINE,
+  TRAILING_OWN_LINE,
+  TRAILING_INLINE,
+}
+
 export function attachComments(
   comments: $ReadOnlyArray<Comment>,
   ast: Program,
@@ -80,18 +88,23 @@ export function isTrailingComment(comment: Comment): boolean {
   return comment.trailing === true;
 }
 
-export function addLeadingComment(
-  node: ESNode | DetachedNode<ESNode>,
-  comment: Comment,
-): void {
-  untypedAddLeadingComment(node, comment);
-}
-
-export function addTrailingComment(
+export function addComment(
   node: ESNode | DetachedNode<ESNode>,
   comment: Comment,
+  placement: CommentPlacement,
 ): void {
-  untypedAddTrailingComment(node, comment);
+  switch (placement) {
+    case CommentPlacement.LEADING_OWN_LINE:
+    case CommentPlacement.LEADING_INLINE: {
+      untypedAddLeadingComment(node, comment);
+      break;
+    }
+    case CommentPlacement.TRAILING_OWN_LINE:
+    case CommentPlacement.TRAILING_INLINE: {
+      untypedAddTrailingComment(node, comment);
+      break;
+    }
+  }
 }
 
 export function cloneComment<T: Comment>(comment: T): T {
@@ -116,30 +129,94 @@ export function cloneCommentWithMarkers<T: Comment>(comment: T): T {
   };
 }
 
-export function appendCommentToSource(code: string, comment: Comment): string {
-  // prettier slices comments directly from the source code when printing
-  // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
-  // this means that we need to have any appended comments directly in the
-  // source code or else prettier will slice nothing and bork up the transform
+function getFirstNewlineIndex(code: string): number {
+  return code.search(/\r\n|\n|\r/);
+}
+
+function getFirstNonWhitespaceIndex(code: string): number {
+  return code.search(/\S/);
+}
 
-  let commentText = comment.value;
+export function appendCommentToSource(
+  code: string,
+  comment: Comment,
+  placement: CommentPlacement,
+): string {
+  let newCode = code;
   switch (comment.type) {
-    case 'Block':
-      commentText = `/*${commentText}*/`;
+    case 'Block': {
+      // Prettier decides if a newline is necessary between the comment and its node by looking
+      // to see if a newline seperates them in the source text. We can trick prettier into
+      // formatting how we want for new comments by placing the range such that a newline
+      // will (OWN_LINE) or will not (INLINE) be found when searching from the specified range
+      // position.
+      switch (placement) {
+        case CommentPlacement.LEADING_OWN_LINE:
+        case CommentPlacement.TRAILING_OWN_LINE: {
+          // Since we always want a line break we need to ensure a newline is found when
+          // searching out from either side of the comment range.
+          let firstNewline = getFirstNewlineIndex(code);
+          if (firstNewline === -1) {
+            // No newline in file, lets add one.
+            newCode += EOL;
+            firstNewline = newCode.length;
+          }
+          // Prettier only uses these ranges for detecting whitespace, so this nonsensical
+          // range is safe.
+          // $FlowExpectedError[cannot-write]
+          comment.range = [firstNewline + 1, firstNewline];
+          break;
+        }
+        case CommentPlacement.LEADING_INLINE:
+        case CommentPlacement.TRAILING_INLINE: {
+          // Since we don't want a line break we need to ensure a non whitespace char is
+          // always found before a newline when searching out from either side of the
+          // comment range.
+          let firstNonWhitespace = getFirstNonWhitespaceIndex(code);
+          if (firstNonWhitespace === -1) {
+            // No non whitespace chars in file, lets add an identifiable statement for prettier to find.
+            newCode += '$FORCE_INLINE_ON_EMPTY_FILE_TOKEN$;';
+            firstNonWhitespace = newCode.length;
+            break;
+          }
+
+          // $FlowExpectedError[cannot-write]
+          comment.range = [firstNonWhitespace + 1, firstNonWhitespace];
+          break;
+        }
+      }
       break;
-    case 'Line':
-      commentText = `//${commentText}`;
+    }
+    case 'Line': {
+      // For `Line` comments prettier slices comments directly from the source code when printing
+      // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
+      // this means that we need to have any appended comments directly in the
+      // source code or else prettier will slice nothing and bork up the transform
+      const commentText = `//${comment.value}`;
+
+      const lastChar = newCode[newCode.length - 1];
+      if (lastChar !== '\n' && lastChar !== '\r') {
+        newCode += EOL;
+      }
+
+      // Line comments cannot be inline before a node so we only place trailing Line comments inline.
+      if (placement === CommentPlacement.TRAILING_INLINE) {
+        // Prettier determines an "end of line" comment by walking backwards from
+        // the comment start range through the source code to see if it finds a non
+        // newline token. In order to trick prettier for new comments we need to
+        // insert fake source code for it to find.
+        newCode += '$FORCE_END_OF_LINE_COMMENT_TOKEN$;';
+      }
+      const start = newCode.length;
+      newCode += commentText;
+      const end = newCode.length;
+
+      // $FlowExpectedError[cannot-write]
+      comment.range = [start, end];
+
       break;
+    }
   }
 
-  let newCode = code;
-  newCode += '\n';
-  const start = newCode.length;
-  newCode += commentText;
-  const end = newCode.length;
-
-  // $FlowExpectedError[cannot-write]
-  comment.range = [start, end];
-
   return newCode;
 }

package/dist/transform/comments/prettier/common/util.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -8,13 +8,11 @@
  */
 'use strict';
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+const stringWidth = require('string-width');
 
-var stringWidth = require('string-width');
+const getLast = require('../utils/get-last.js');
 
-var getLast = require('../utils/get-last.js');
-
-var notAsciiRegex = /[^\x20-\x7F]/;
+const notAsciiRegex = /[^\x20-\x7F]/;
 /**
  * @typedef {{backwards?: boolean}} SkipOptions
  */
@@ -25,8 +23,8 @@ var notAsciiRegex = /[^\x20-\x7F]/;
  */
 
 function skip(chars) {
-  return function (text, index, opts) {
-    var backwards = opts && opts.backwards; // Allow `skip` functions to be threaded together without having
+  return (text, index, opts) => {
+    const backwards = opts && opts.backwards; // Allow `skip` functions to be threaded together without having
     // to check for failures (did someone say monads?).
 
     /* istanbul ignore next */
@@ -35,11 +33,13 @@ function skip(chars) {
       return false;
     }
 
-    var length = text.length;
-    var cursor = index;
+    const {
+      length
+    } = text;
+    let cursor = index;
 
     while (cursor >= 0 && cursor < length) {
-      var c = text.charAt(cursor);
+      const c = text.charAt(cursor);
 
       if (chars instanceof RegExp) {
         if (!chars.test(c)) {
@@ -68,22 +68,22 @@ function skip(chars) {
  */
 
 
-var skipWhitespace = skip(/\s/);
+const skipWhitespace = skip(/\s/);
 /**
  * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
  */
 
-var skipSpaces = skip(' \t');
+const skipSpaces = skip(' \t');
 /**
  * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
  */
 
-var skipToLineEnd = skip(',; \t');
+const skipToLineEnd = skip(',; \t');
 /**
  * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
  */
 
-var skipEverythingButNewLine = skip(/[^\n\r]/);
+const skipEverythingButNewLine = skip(/[^\n\r]/);
 /**
  * @param {string} text
  * @param {number | false} index
@@ -97,7 +97,7 @@ function skipInlineComment(text, index) {
   }
 
   if (text.charAt(index) === '/' && text.charAt(index + 1) === '*') {
-    for (var i = index + 2; i < text.length; ++i) {
+    for (let i = index + 2; i < text.length; ++i) {
       if (text.charAt(i) === '*' && text.charAt(i + 1) === '/') {
         return i + 2;
       }
@@ -137,13 +137,13 @@ function skipTrailingComment(text, index) {
 
 
 function skipNewline(text, index, opts) {
-  var backwards = opts && opts.backwards;
+  const backwards = opts && opts.backwards;
 
   if (index === false) {
     return false;
   }
 
-  var atIndex = text.charAt(index);
+  const atIndex = text.charAt(index);
 
   if (backwards) {
     // We already replace `\r\n` with `\n` before parsing
@@ -153,7 +153,7 @@ function skipNewline(text, index, opts) {
       return index - 2;
     }
 
-    if (atIndex === '\n' || atIndex === '\r' || atIndex === "\u2028" || atIndex === "\u2029") {
+    if (atIndex === '\n' || atIndex === '\r' || atIndex === '\u2028' || atIndex === '\u2029') {
       return index - 1;
     }
   } else {
@@ -164,7 +164,7 @@ function skipNewline(text, index, opts) {
       return index + 2;
     }
 
-    if (atIndex === '\n' || atIndex === '\r' || atIndex === "\u2028" || atIndex === "\u2029") {
+    if (atIndex === '\n' || atIndex === '\r' || atIndex === '\u2028' || atIndex === '\u2029') {
       return index + 1;
     }
   }
@@ -179,10 +179,9 @@ function skipNewline(text, index, opts) {
  */
 
 
-function hasNewline(text, index) {
-  var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts);
-  var idx2 = skipNewline(text, idx, opts);
+function hasNewline(text, index, opts = {}) {
+  const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts);
+  const idx2 = skipNewline(text, idx, opts);
   return idx !== idx2;
 }
 /**
@@ -194,7 +193,7 @@ function hasNewline(text, index) {
 
 
 function hasNewlineInRange(text, start, end) {
-  for (var i = start; i < end; ++i) {
+  for (let i = start; i < end; ++i) {
     if (text.charAt(i) === '\n') {
       return true;
     }
@@ -211,10 +210,10 @@ function hasNewlineInRange(text, start, end) {
 
 function isNextLineEmptyAfterIndex(text, index) {
   /** @type {number | false} */
-  var oldIdx = null;
+  let oldIdx = null;
   /** @type {number | false} */
 
-  var idx = index;
+  let idx = index;
 
   while (idx !== oldIdx) {
     // We need to skip all the potential trailing inline comments
@@ -237,10 +236,10 @@ function isNextLineEmptyAfterIndex(text, index) {
 
 function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, idx) {
   /** @type {number | false} */
-  var oldIdx = null;
+  let oldIdx = null;
   /** @type {number | false} */
 
-  var nextIdx = idx;
+  let nextIdx = idx;
 
   while (nextIdx !== oldIdx) {
     oldIdx = nextIdx;
@@ -297,7 +296,7 @@ function getStringWidth(text) {
 }
 
 function addCommentHelper(node, comment) {
-  var comments = node.comments || (node.comments = []);
+  const comments = node.comments || (node.comments = []);
   comments.push(comment);
   comment.printed = false;
   comment.nodeDescription = describeNodeForDebugging(node);
@@ -336,8 +335,8 @@ function isNonEmptyArray(object) {
 }
 
 function describeNodeForDebugging(node) {
-  var nodeType = node.type || node.kind || '(unknown type)';
-  var nodeName = String(node.name || node.id && (_typeof(node.id) === 'object' ? node.id.name : node.id) || node.key && (_typeof(node.key) === 'object' ? node.key.name : node.key) || node.value && (_typeof(node.value) === 'object' ? '' : String(node.value)) || node.operator || '');
+  const nodeType = node.type || node.kind || '(unknown type)';
+  let nodeName = String(node.name || node.id && (typeof node.id === 'object' ? node.id.name : node.id) || node.key && (typeof node.key === 'object' ? node.key.name : node.key) || node.value && (typeof node.value === 'object' ? '' : String(node.value)) || node.operator || '');
 
   if (nodeName.length > 20) {
     nodeName = nodeName.slice(0, 19) + '…';
@@ -347,19 +346,19 @@ function describeNodeForDebugging(node) {
 }
 
 module.exports = {
-  getStringWidth: getStringWidth,
-  getLast: getLast,
-  getNextNonSpaceNonCommentCharacterIndexWithStartIndex: getNextNonSpaceNonCommentCharacterIndexWithStartIndex,
-  getNextNonSpaceNonCommentCharacterIndex: getNextNonSpaceNonCommentCharacterIndex,
-  getNextNonSpaceNonCommentCharacter: getNextNonSpaceNonCommentCharacter,
-  skipWhitespace: skipWhitespace,
-  skipSpaces: skipSpaces,
-  skipNewline: skipNewline,
-  isNextLineEmptyAfterIndex: isNextLineEmptyAfterIndex,
-  hasNewline: hasNewline,
-  hasNewlineInRange: hasNewlineInRange,
-  addLeadingComment: addLeadingComment,
-  addDanglingComment: addDanglingComment,
-  addTrailingComment: addTrailingComment,
-  isNonEmptyArray: isNonEmptyArray
+  getStringWidth,
+  getLast,
+  getNextNonSpaceNonCommentCharacterIndexWithStartIndex,
+  getNextNonSpaceNonCommentCharacterIndex,
+  getNextNonSpaceNonCommentCharacter,
+  skipWhitespace,
+  skipSpaces,
+  skipNewline,
+  isNextLineEmptyAfterIndex,
+  hasNewline,
+  hasNewlineInRange,
+  addLeadingComment,
+  addDanglingComment,
+  addTrailingComment,
+  isNonEmptyArray
 };

package/dist/transform/comments/prettier/common/util.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.