Avoid matching polyfilled global names in NameEngine.

Fix #22.

PiperOrigin-RevId: 354387758
Change-Id: I659f36dd0eb608aa252a908f6271a2fafd126191

src/third_party/tsetse/util/absolute_matcher.ts

@@ -111,13 +111,6 @@ export class AbsoluteMatcher {
  debugLog(() => `start matching ${n.getText()} in ${p?.getText()}`);
 
  if (p !== undefined) {
- // Do not match global symbols appearing on the LHS of an assignment
- // expression. This avoids false positives in polyfill code.
- if (this.filePath === GLOBAL && ts.isBinaryExpression(p) &&
- p.left === n && p.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
- return false;
- }
-
  // Check if the node is being declared. Declaration may be imported
  // without programmer being aware of. We should not alert them about that.
  // Since import statments are also declarations, this have two notable

src/third_party/tsetse/util/ast_tools.ts

@@ -70,6 +70,21 @@ export function shouldExamineNode(n: ts.Node) {
  isInStockLibraries(n));
 }
 
+/**
+ * Returns the top-level property access expression (or element access
+ * expression) that the input node is part of.
+ *
+ * For example, given an expression `c` which is part of `a['b'].c = 1;`,
+ * the function returns the whole LHS expression `a['b'].c`.
+ */
+export function walkUpPropertyAndElementAccess(n: ts.Node): ts.Node {
+ while (ts.isPropertyAccessExpression(n.parent) ||
+ ts.isElementAccessExpression(n.parent)) {
+ n = n.parent;
+ }
+ return n;
+}
+
 /**
  * Return whether the given Node is (or is in) a library included as default.
  * We currently look for a node_modules/typescript/ prefix, but this could

src/third_party/tsetse/util/pattern_engines/name_engine.ts

@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 
 import {Checker} from '../../checker';
 import {AbsoluteMatcher} from '../absolute_matcher';
+import {walkUpPropertyAndElementAccess} from '../ast_tools';
 import {isExpressionOfAllowedTrustedType} from '../is_trusted_type';
 import {TrustedTypesConfig} from '../trusted_types_configuration';
 
@@ -21,19 +22,32 @@ function isCalledWithAllowedTrustedType(
  return false;
 }
 
+function isPolyfill(n: ts.Node, matcher: AbsoluteMatcher) {
+ if (matcher.filePath === 'GLOBAL') {
+ const wholeExp = walkUpPropertyAndElementAccess(n);
+ const parent = wholeExp.parent;
+ if (parent && ts.isBinaryExpression(parent) && parent.left === wholeExp &&
+ parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+ return true;
+ }
+ }
+ return false;
+}
+
 function checkIdentifierNode(
  tc: ts.TypeChecker, n: ts.Identifier, matcher: AbsoluteMatcher,
  allowedTrustedType: TrustedTypesConfig|undefined): ts.Node|undefined {
+ if (isPolyfill(n, matcher)) return;
  if (!matcher.matches(n, tc)) return;
  if (isCalledWithAllowedTrustedType(tc, n, allowedTrustedType)) return;
 
-
  return n;
 }
 
 function checkElementAccessNode(
  tc: ts.TypeChecker, n: ts.ElementAccessExpression, matcher: AbsoluteMatcher,
  allowedTrustedType: TrustedTypesConfig|undefined): ts.Node|undefined {
+ if (isPolyfill(n, matcher)) return;
  if (!matcher.matches(n.argumentExpression, tc)) return;
  if (isCalledWithAllowedTrustedType(tc, n, allowedTrustedType)) return;
 
@@ -46,9 +60,9 @@ export class NameEngine extends PatternEngine {
  for (const value of this.config.values) {
  const matcher = new AbsoluteMatcher(value);
 
- // `String.prototype.split` only returns emtpy array when both the string
- // and the splitter are empty. Here we should be able to safely assert pop
- // returns a non-null result.
+ // `String.prototype.split` only returns emtpy array when both the
+ // string and the splitter are empty. Here we should be able to safely
+ // assert pop returns a non-null result.
  const bannedIdName = matcher.bannedName.split('.').pop()!;
  checker.onNamedIdentifier(
  bannedIdName,