0.2.0 - Mid migration

web/node_modules/babel-eslint/lib/babylon-to-espree/attachComments.js

@@ -0,0 +1,59 @@
+"use strict";
+
+// comment fixes
+module.exports = function(ast, comments, tokens) {
+  if (comments.length) {
+    var firstComment = comments[0];
+    var lastComment = comments[comments.length - 1];
+    // fixup program start
+    if (!tokens.length) {
+      // if no tokens, the program starts at the end of the last comment
+      ast.start = lastComment.end;
+      ast.loc.start.line = lastComment.loc.end.line;
+      ast.loc.start.column = lastComment.loc.end.column;
+
+      if (ast.leadingComments === null && ast.innerComments.length) {
+        ast.leadingComments = ast.innerComments;
+      }
+    } else if (firstComment.start < tokens[0].start) {
+      // if there are comments before the first token, the program starts at the first token
+      var token = tokens[0];
+      // ast.start = token.start;
+      // ast.loc.start.line = token.loc.start.line;
+      // ast.loc.start.column = token.loc.start.column;
+
+      // estraverse do not put leading comments on first node when the comment
+      // appear before the first token
+      if (ast.body.length) {
+        var node = ast.body[0];
+        node.leadingComments = [];
+        var firstTokenStart = token.start;
+        var len = comments.length;
+        for (var i = 0; i < len && comments[i].start < firstTokenStart; i++) {
+          node.leadingComments.push(comments[i]);
+        }
+      }
+    }
+    // fixup program end
+    if (tokens.length) {
+      var lastToken = tokens[tokens.length - 1];
+      if (lastComment.end > lastToken.end) {
+        // If there is a comment after the last token, the program ends at the
+        // last token and not the comment
+        // ast.end = lastToken.end;
+        ast.range[1] = lastToken.end;
+        ast.loc.end.line = lastToken.loc.end.line;
+        ast.loc.end.column = lastToken.loc.end.column;
+      }
+    }
+  } else {
+    if (!tokens.length) {
+      ast.loc.start.line = 1;
+      ast.loc.end.line = 1;
+    }
+  }
+  if (ast.body && ast.body.length > 0) {
+    ast.loc.start.line = ast.body[0].loc.start.line;
+    ast.range[0] = ast.body[0].start;
+  }
+};

web/node_modules/babel-eslint/lib/babylon-to-espree/convertComments.js

@@ -0,0 +1,17 @@
+"use strict";
+
+module.exports = function(comments) {
+  for (var i = 0; i < comments.length; i++) {
+    var comment = comments[i];
+    if (comment.type === "CommentBlock") {
+      comment.type = "Block";
+    } else if (comment.type === "CommentLine") {
+      comment.type = "Line";
+    }
+    // sometimes comments don't get ranges computed,
+    // even with options.ranges === true
+    if (!comment.range) {
+      comment.range = [comment.start, comment.end];
+    }
+  }
+};

web/node_modules/babel-eslint/lib/babylon-to-espree/convertTemplateType.js

@@ -0,0 +1,92 @@
+"use strict";
+
+module.exports = function(tokens, tt) {
+  let curlyBrace = null;
+  let templateTokens = [];
+  const result = [];
+
+  function addTemplateType() {
+    const start = templateTokens[0];
+    const end = templateTokens[templateTokens.length - 1];
+
+    const value = templateTokens.reduce((result, token) => {
+      if (token.value) {
+        result += token.value;
+      } else if (token.type !== tt.template) {
+        result += token.type.label;
+      }
+
+      return result;
+    }, "");
+
+    result.push({
+      type: "Template",
+      value: value,
+      start: start.start,
+      end: end.end,
+      loc: {
+        start: start.loc.start,
+        end: end.loc.end,
+      },
+    });
+
+    templateTokens = [];
+  }
+
+  tokens.forEach(token => {
+    switch (token.type) {
+      case tt.backQuote:
+        if (curlyBrace) {
+          result.push(curlyBrace);
+          curlyBrace = null;
+        }
+
+        templateTokens.push(token);
+
+        if (templateTokens.length > 1) {
+          addTemplateType();
+        }
+
+        break;
+
+      case tt.dollarBraceL:
+        templateTokens.push(token);
+        addTemplateType();
+        break;
+
+      case tt.braceR:
+        if (curlyBrace) {
+          result.push(curlyBrace);
+        }
+
+        curlyBrace = token;
+        break;
+
+      case tt.template:
+        if (curlyBrace) {
+          templateTokens.push(curlyBrace);
+          curlyBrace = null;
+        }
+
+        templateTokens.push(token);
+        break;
+
+      case tt.eof:
+        if (curlyBrace) {
+          result.push(curlyBrace);
+        }
+
+        break;
+
+      default:
+        if (curlyBrace) {
+          result.push(curlyBrace);
+          curlyBrace = null;
+        }
+
+        result.push(token);
+    }
+  });
+
+  return result;
+};

web/node_modules/babel-eslint/lib/babylon-to-espree/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var attachComments = require("./attachComments");
+var convertComments = require("./convertComments");
+var toTokens = require("./toTokens");
+var toAST = require("./toAST");
+
+module.exports = function(ast, traverse, tt, code) {
+  // convert tokens
+  ast.tokens = toTokens(ast.tokens, tt, code);
+
+  // add comments
+  convertComments(ast.comments);
+
+  // transform esprima and acorn divergent nodes
+  toAST(ast, traverse, code);
+
+  // ast.program.tokens = ast.tokens;
+  // ast.program.comments = ast.comments;
+  // ast = ast.program;
+
+  // remove File
+  ast.type = "Program";
+  ast.sourceType = ast.program.sourceType;
+  ast.directives = ast.program.directives;
+  ast.body = ast.program.body;
+  delete ast.program;
+
+  attachComments(ast, ast.comments, ast.tokens);
+};

web/node_modules/babel-eslint/lib/babylon-to-espree/toAST.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var t = require("@babel/types");
+var convertComments = require("./convertComments");
+
+module.exports = function(ast, traverse, code) {
+  var state = { source: code };
+
+  // Monkey patch visitor keys in order to be able to traverse the estree nodes
+  t.VISITOR_KEYS.Property = t.VISITOR_KEYS.ObjectProperty;
+  t.VISITOR_KEYS.MethodDefinition = [
+    "key",
+    "value",
+    "decorators",
+    "returnType",
+    "typeParameters",
+  ];
+
+  traverse(ast, astTransformVisitor, null, state);
+
+  delete t.VISITOR_KEYS.Property;
+  delete t.VISITOR_KEYS.MethodDefinition;
+};
+
+var astTransformVisitor = {
+  noScope: true,
+  enter(path) {
+    var node = path.node;
+
+    // private var to track original node type
+    node._babelType = node.type;
+
+    if (node.innerComments) {
+      node.trailingComments = node.innerComments;
+      delete node.innerComments;
+    }
+
+    if (node.trailingComments) {
+      convertComments(node.trailingComments);
+    }
+
+    if (node.leadingComments) {
+      convertComments(node.leadingComments);
+    }
+  },
+  exit(path) {
+    var node = path.node;
+
+    if (path.isJSXText()) {
+      node.type = "Literal";
+    }
+
+    if (
+      path.isRestElement() &&
+      path.parent &&
+      path.parent.type === "ObjectPattern"
+    ) {
+      node.type = "ExperimentalRestProperty";
+    }
+
+    if (
+      path.isSpreadElement() &&
+      path.parent &&
+      path.parent.type === "ObjectExpression"
+    ) {
+      node.type = "ExperimentalSpreadProperty";
+    }
+
+    if (path.isTypeParameter()) {
+      node.type = "Identifier";
+      node.typeAnnotation = node.bound;
+      delete node.bound;
+    }
+
+    // flow: prevent "no-undef"
+    // for "Component" in: "let x: React.Component"
+    if (path.isQualifiedTypeIdentifier()) {
+      delete node.id;
+    }
+    // for "b" in: "var a: { b: Foo }"
+    if (path.isObjectTypeProperty()) {
+      delete node.key;
+    }
+    // for "indexer" in: "var a: {[indexer: string]: number}"
+    if (path.isObjectTypeIndexer()) {
+      delete node.id;
+    }
+    // for "param" in: "var a: { func(param: Foo): Bar };"
+    if (path.isFunctionTypeParam()) {
+      delete node.name;
+    }
+
+    // modules
+
+    if (path.isImportDeclaration()) {
+      delete node.isType;
+    }
+
+    // template string range fixes
+    if (path.isTemplateLiteral()) {
+      for (var j = 0; j < node.quasis.length; j++) {
+        var q = node.quasis[j];
+        q.range[0] -= 1;
+        if (q.tail) {
+          q.range[1] += 1;
+        } else {
+          q.range[1] += 2;
+        }
+        q.loc.start.column -= 1;
+        if (q.tail) {
+          q.loc.end.column += 1;
+        } else {
+          q.loc.end.column += 2;
+        }
+      }
+    }
+  },
+};

web/node_modules/babel-eslint/lib/babylon-to-espree/toToken.js

@@ -0,0 +1,84 @@
+"use strict";
+
+module.exports = function(token, tt, source) {
+  var type = token.type;
+  token.range = [token.start, token.end];
+
+  if (type === tt.name) {
+    token.type = "Identifier";
+  } else if (
+    type === tt.semi ||
+    type === tt.comma ||
+    type === tt.parenL ||
+    type === tt.parenR ||
+    type === tt.braceL ||
+    type === tt.braceR ||
+    type === tt.slash ||
+    type === tt.dot ||
+    type === tt.bracketL ||
+    type === tt.bracketR ||
+    type === tt.ellipsis ||
+    type === tt.arrow ||
+    type === tt.pipeline ||
+    type === tt.star ||
+    type === tt.incDec ||
+    type === tt.colon ||
+    type === tt.question ||
+    type === tt.questionDot ||
+    type === tt.template ||
+    type === tt.backQuote ||
+    type === tt.dollarBraceL ||
+    type === tt.at ||
+    type === tt.logicalOR ||
+    type === tt.logicalAND ||
+    type === tt.nullishCoalescing ||
+    type === tt.bitwiseOR ||
+    type === tt.bitwiseXOR ||
+    type === tt.bitwiseAND ||
+    type === tt.equality ||
+    type === tt.relational ||
+    type === tt.bitShift ||
+    type === tt.plusMin ||
+    type === tt.modulo ||
+    type === tt.exponent ||
+    type === tt.bang ||
+    type === tt.tilde ||
+    type === tt.doubleColon ||
+    type.isAssign
+  ) {
+    token.type = "Punctuator";
+    if (!token.value) token.value = type.label;
+  } else if (type === tt.jsxTagStart) {
+    token.type = "Punctuator";
+    token.value = "<";
+  } else if (type === tt.jsxTagEnd) {
+    token.type = "Punctuator";
+    token.value = ">";
+  } else if (type === tt.jsxName) {
+    token.type = "JSXIdentifier";
+  } else if (type === tt.jsxText) {
+    token.type = "JSXText";
+  } else if (type.keyword === "null") {
+    token.type = "Null";
+  } else if (type.keyword === "false" || type.keyword === "true") {
+    token.type = "Boolean";
+  } else if (type.keyword) {
+    token.type = "Keyword";
+  } else if (type === tt.num) {
+    token.type = "Numeric";
+    token.value = source.slice(token.start, token.end);
+  } else if (type === tt.string) {
+    token.type = "String";
+    token.value = source.slice(token.start, token.end);
+  } else if (type === tt.regexp) {
+    token.type = "RegularExpression";
+    var value = token.value;
+    token.regex = {
+      pattern: value.pattern,
+      flags: value.flags,
+    };
+    token.value = `/${value.pattern}/${value.flags}`;
+  }
+
+  return token;
+};

web/node_modules/babel-eslint/lib/babylon-to-espree/toTokens.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var convertTemplateType = require("./convertTemplateType");
+var toToken = require("./toToken");
+
+module.exports = function(tokens, tt, code) {
+  return convertTemplateType(tokens, tt)
+    .filter(t => t.type !== "CommentLine" && t.type !== "CommentBlock")
+    .map(t => toToken(t, tt, code));
+};