Scope Analysis

babel-parser
└── src
     └── util
         ├── class-scope.js
         ├── identifier.js
         ├── location.js
         ├── production-parameter.js
         ├── scope.js
         ├── scopeflags.js
         └── whitespace.js

export class ClassScope {
  privateNames: Set<string> = new Set();
  loneAccessors: Map<string, ClassElementTypes> = new Map(); // for getters and setters
  undefinedPrivateNames: Map<string, number> = new Map();
}

export default class ClassScopeHandler {
  stack: Array<ClassScope> = [];
  raise: raiseFunction;
  undefinedPrivateNames: Map<string, number> = new Map();
 
  constructor(raise: raiseFunction) {
    this.raise = raise;
  }
 
  current(): ClassScope {
    return this.stack[this.stack.length - 1];
  }
 
  enter() {
    this.stack.push(new ClassScope());
  }
 
  exit() {
    const oldClassScope = this.stack.pop();
 
    // Migrate the usage of not yet defined private names to the outer
    // class scope, or raise an error if we reached the top-level scope.
 
    const current = this.current();
 
    // Array.from is needed because this is compiled to an array-like for loop
    for (const [name, pos] of Array.from(oldClassScope.undefinedPrivateNames)) {
      if (current) {
        if (!current.undefinedPrivateNames.has(name)) {
          current.undefinedPrivateNames.set(name, pos);
        }
      } else {
        this.raise(pos, Errors.InvalidPrivateFieldResolution, name);
      }
    }
  }
 
  declarePrivateName(
    name: string,
    elementType: ClassElementTypes,
    pos: number,
  ) {
    const classScope = this.current();
    let redefined = classScope.privateNames.has(name);
 
    if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) {
      const accessor = redefined && classScope.loneAccessors.get(name);
      if (accessor) {
        const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC;
        const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC;
 
        const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR;
        const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR;
 
        // The private name can be duplicated only if it is used by
        // two accessors with different kind (get and set), and if
        // they have the same placement (static or not).
        redefined = oldKind === newKind || oldStatic !== newStatic;
 
        if (!redefined) classScope.loneAccessors.delete(name);
      } else if (!redefined) {
        classScope.loneAccessors.set(name, elementType);
      }
    }
 
    if (redefined) {
      this.raise(pos, Errors.PrivateNameRedeclaration, name);
    }
 
    classScope.privateNames.add(name);
    classScope.undefinedPrivateNames.delete(name);
  }
 
  usePrivateName(name: string, pos: number) {
    let classScope;
    for (classScope of this.stack) {
      if (classScope.privateNames.has(name)) return;
    }
 
    if (classScope) {
      classScope.undefinedPrivateNames.set(name, pos);
    } else {
      // top-level
      this.raise(pos, Errors.InvalidPrivateFieldResolution, name);
    }
  }
}

...
import type ScopeHandler from "../util/scope";
import type ClassScopeHandler from "../util/class-scope";
 
export default class BaseParser {
  // Properties set by constructor in index.js
  options: Options;       // Configurations options
  inModule: boolean;      // True if the code is in a module
  scope: ScopeHandler<*>; // Generic type
  classScope: ClassScopeHandler;
  ...
 
  state: State;  // Initialized by Tokenizer
  // input and length are not in state as they are constant and we do
  // not want to ever copy them, which happens if state gets cloned
  input: string;
  length: number;
  hasPlugin(name: string): boolean { return this.plugins.has(name); } // checks if a given plugin is available in the plugins map
  getPluginOption(plugin: string, name: string) { if (this.hasPlugin(plugin)) return this.plugins.get(plugin)[name]; } // Retrieves an option for a specified plugin
}

import BaseParser from "./base";
...
 
export default class CommentsParser extends BaseParser { ... }

 src
  ├── parser
  │   ├── base.js
  │   ├── comments.js
  │   ├── error-message.js
  │   ├── error.js
  │   ├── expression.js
  │   ├── index.js
  │   ├── lval.js
  │   ├── node.js
  │   ├── statement.js
  │   └── util.js

import { getLineInfo, type Position } from "../util/location";
import CommentsParser from "./comments";
type ErrorContext = {
  pos: number,
  loc: Position,
  missingPlugin?: Array<string>,
  code?: string,
};
 
export { ErrorMessages as Errors } from "./error-message.js";
export default class ParserError extends CommentsParser { ... }

import type { Options } from "../options";
import type { File /*::, JSXOpeningElement */ } from "../types";
import type { PluginList } from "../plugin-utils";
import { getOptions } from "../options";
import StatementParser from "./statement";
import { SCOPE_PROGRAM } from "../util/scopeflags";
import ScopeHandler from "../util/scope";
import ClassScopeHandler from "../util/class-scope";
import ProductionParameterHandler, { PARAM_AWAIT, PARAM, } from "../util/production-parameter";
 
export type PluginsMap = Map<string, { [string]: any }>;
 
export default class Parser extends StatementParser { ... } 

export default class Parser extends StatementParser {
  constructor(options: ?Options, input: string) { ... }
 
  getScopeHandler(): Class<ScopeHandler<*>> { return ScopeHandler; }
 
  parse(): File { ... }
}
 
function pluginsMap(plugins: PluginList): PluginsMap {
  const pluginMap: PluginsMap = new Map();
  for (const plugin of plugins) {
    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
    if (!pluginMap.has(name)) pluginMap.set(name, options || {});
  }
  return pluginMap;
}

  constructor(options: ?Options, input: string) {
    options = getOptions(options);
    super(options, input);
 
    const ScopeHandler = this.getScopeHandler();
 
    this.options = options;
    this.inModule = this.options.sourceType === "module";
    this.scope = new ScopeHandler(this.raise.bind(this), this.inModule);
    this.prodParam = new ProductionParameterHandler();
    this.classScope = new ClassScopeHandler(this.raise.bind(this));
    this.plugins = pluginsMap(this.options.plugins);
    this.filename = options.sourceFilename;
  }

  parse(): File {
    let paramFlags = PARAM;
    if (this.hasPlugin("topLevelAwait") && this.inModule) {
      paramFlags |= PARAM_AWAIT;
    }
    this.scope.enter(SCOPE_PROGRAM); 
    this.prodParam.enter(paramFlags);
    const file = this.startNode();
    const program = this.startNode();
    this.nextToken();
    file.errors = null;
    this.parseTopLevel(file, program);
    file.errors = this.state.errors;
    return file;
  }
}