@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/compiler/lower_arrays.js

@@ -0,0 +1,140 @@
+import ts from 'typescript';
+import { getHostTaggedBoundaryKinds, isNullType, isStringLikeType, isUndefinedType, } from './lower_tagged.js';
+function isSupportedOwnedArrayType(checker, type, isSupportedElementType) {
+    if (checker.isArrayType(type)) {
+        const elementType = (type.flags & ts.TypeFlags.Object) !== 0
+            ? checker.getTypeArguments(type)[0]
+            : undefined;
+        return elementType ? isSupportedElementType(elementType) : false;
+    }
+    if (checker.isTupleType(type) && (type.flags & ts.TypeFlags.Object) !== 0) {
+        const typeArguments = checker.getTypeArguments(type);
+        return typeArguments.length > 0 &&
+            typeArguments.every((member) => isSupportedElementType(member));
+    }
+    return false;
+}
+export function isSupportedOwnedStringArrayType(checker, type) {
+    return isSupportedOwnedArrayType(checker, type, isStringLikeType);
+}
+export function isSupportedOwnedNumberArrayType(checker, type) {
+    return isSupportedOwnedArrayType(checker, type, (elementType) => (elementType.flags & ts.TypeFlags.NumberLike) !== 0);
+}
+export function isSupportedOwnedBooleanArrayType(checker, type) {
+    return isSupportedOwnedArrayType(checker, type, (elementType) => (elementType.flags & ts.TypeFlags.BooleanLike) !== 0);
+}
+function isSupportedOwnedHeapArrayElementType(checker, type) {
+    if (isStringLikeType(type) || (type.flags & ts.TypeFlags.NumberLike) !== 0 ||
+        (type.flags & ts.TypeFlags.BooleanLike) !== 0 || isUndefinedType(type) || isNullType(type)) {
+        return false;
+    }
+    if (getHostTaggedBoundaryKinds(type)) {
+        return false;
+    }
+    if (checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0) {
+        return false;
+    }
+    if (checker.isArrayType(type) || checker.isTupleType(type)) {
+        return isSupportedOwnedStringArrayType(checker, type) ||
+            isSupportedOwnedNumberArrayType(checker, type) ||
+            isSupportedOwnedBooleanArrayType(checker, type) ||
+            isSupportedOwnedTaggedArrayType(checker, type) ||
+            isSupportedOwnedHeapArrayType(checker, type);
+    }
+    return (type.flags & ts.TypeFlags.Object) !== 0 || (type.flags & ts.TypeFlags.Union) !== 0;
+}
+export function isSupportedOwnedHeapArrayType(checker, type) {
+    return isSupportedOwnedArrayType(checker, type, (elementType) => isSupportedOwnedHeapArrayElementType(checker, elementType));
+}
+function getTaggedArrayElementKinds(type) {
+    const boundaryKinds = getHostTaggedBoundaryKinds(type);
+    if (boundaryKinds) {
+        return boundaryKinds;
+    }
+    if ((type.flags & ts.TypeFlags.NumberLike) !== 0) {
+        return {
+            includesBoolean: false,
+            includesNull: false,
+            includesNumber: true,
+            includesString: false,
+            includesUndefined: false,
+        };
+    }
+    if ((type.flags & ts.TypeFlags.BooleanLike) !== 0) {
+        return {
+            includesBoolean: true,
+            includesNull: false,
+            includesNumber: false,
+            includesString: false,
+            includesUndefined: false,
+        };
+    }
+    if (isStringLikeType(type)) {
+        return {
+            includesBoolean: false,
+            includesNull: false,
+            includesNumber: false,
+            includesString: true,
+            includesUndefined: false,
+        };
+    }
+    if (isUndefinedType(type)) {
+        return {
+            includesBoolean: false,
+            includesNull: false,
+            includesNumber: false,
+            includesString: false,
+            includesUndefined: true,
+        };
+    }
+    if (isNullType(type)) {
+        return {
+            includesBoolean: false,
+            includesNull: true,
+            includesNumber: false,
+            includesString: false,
+            includesUndefined: false,
+        };
+    }
+    return undefined;
+}
+export function getSupportedOwnedTaggedArrayKinds(checker, type) {
+    if (isSupportedOwnedStringArrayType(checker, type) || isSupportedOwnedNumberArrayType(checker, type) ||
+        isSupportedOwnedBooleanArrayType(checker, type)) {
+        return undefined;
+    }
+    if ((type.flags & ts.TypeFlags.Object) === 0) {
+        return undefined;
+    }
+    const elementTypes = checker.isArrayType(type) || checker.isTupleType(type)
+        ? checker.getTypeArguments(type)
+        : undefined;
+    if (!elementTypes || elementTypes.length === 0) {
+        return undefined;
+    }
+    const merged = {
+        includesBoolean: false,
+        includesNull: false,
+        includesNumber: false,
+        includesString: false,
+        includesUndefined: false,
+    };
+    for (const elementType of elementTypes) {
+        const kinds = getTaggedArrayElementKinds(elementType);
+        if (!kinds) {
+            return undefined;
+        }
+        merged.includesBoolean || (merged.includesBoolean = kinds.includesBoolean);
+        merged.includesNull || (merged.includesNull = kinds.includesNull);
+        merged.includesNumber || (merged.includesNumber = kinds.includesNumber);
+        merged.includesString || (merged.includesString = kinds.includesString);
+        merged.includesUndefined || (merged.includesUndefined = kinds.includesUndefined);
+    }
+    return merged.includesBoolean || merged.includesNull || merged.includesNumber ||
+        merged.includesString || merged.includesUndefined
+        ? merged
+        : undefined;
+}
+export function isSupportedOwnedTaggedArrayType(checker, type) {
+    return getSupportedOwnedTaggedArrayKinds(checker, type) !== undefined;
+}

package/project-transform/src/compiler/lower_arrays.ts

@@ -0,0 +1,190 @@
+import ts from 'typescript';
+
+import {
+  getHostTaggedBoundaryKinds,
+  isNullType,
+  isStringLikeType,
+  isUndefinedType,
+} from './lower_tagged.ts';
+
+function isSupportedOwnedArrayType(
+  checker: ts.TypeChecker,
+  type: ts.Type,
+  isSupportedElementType: (elementType: ts.Type) => boolean,
+): boolean {
+  if (checker.isArrayType(type)) {
+    const elementType = (type.flags & ts.TypeFlags.Object) !== 0
+      ? checker.getTypeArguments(type as ts.TypeReference)[0]
+      : undefined;
+    return elementType ? isSupportedElementType(elementType) : false;
+  }
+  if (checker.isTupleType(type) && (type.flags & ts.TypeFlags.Object) !== 0) {
+    const typeArguments = checker.getTypeArguments(type as ts.TypeReference);
+    return typeArguments.length > 0 &&
+      typeArguments.every((member) => isSupportedElementType(member));
+  }
+  return false;
+}
+
+export function isSupportedOwnedStringArrayType(checker: ts.TypeChecker, type: ts.Type): boolean {
+  return isSupportedOwnedArrayType(checker, type, isStringLikeType);
+}
+
+export function isSupportedOwnedNumberArrayType(checker: ts.TypeChecker, type: ts.Type): boolean {
+  return isSupportedOwnedArrayType(
+    checker,
+    type,
+    (elementType) => (elementType.flags & ts.TypeFlags.NumberLike) !== 0,
+  );
+}
+
+export function isSupportedOwnedBooleanArrayType(checker: ts.TypeChecker, type: ts.Type): boolean {
+  return isSupportedOwnedArrayType(
+    checker,
+    type,
+    (elementType) => (elementType.flags & ts.TypeFlags.BooleanLike) !== 0,
+  );
+}
+
+function isSupportedOwnedHeapArrayElementType(
+  checker: ts.TypeChecker,
+  type: ts.Type,
+): boolean {
+  if (isStringLikeType(type) || (type.flags & ts.TypeFlags.NumberLike) !== 0 ||
+    (type.flags & ts.TypeFlags.BooleanLike) !== 0 || isUndefinedType(type) || isNullType(type)
+  ) {
+    return false;
+  }
+  if (getHostTaggedBoundaryKinds(type)) {
+    return false;
+  }
+  if (checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0) {
+    return false;
+  }
+  if (checker.isArrayType(type) || checker.isTupleType(type)) {
+    return isSupportedOwnedStringArrayType(checker, type) ||
+      isSupportedOwnedNumberArrayType(checker, type) ||
+      isSupportedOwnedBooleanArrayType(checker, type) ||
+      isSupportedOwnedTaggedArrayType(checker, type) ||
+      isSupportedOwnedHeapArrayType(checker, type);
+  }
+  return (type.flags & ts.TypeFlags.Object) !== 0 || (type.flags & ts.TypeFlags.Union) !== 0;
+}
+
+export function isSupportedOwnedHeapArrayType(checker: ts.TypeChecker, type: ts.Type): boolean {
+  return isSupportedOwnedArrayType(
+    checker,
+    type,
+    (elementType) => isSupportedOwnedHeapArrayElementType(checker, elementType),
+  );
+}
+
+function getTaggedArrayElementKinds(type: ts.Type): {
+  includesBoolean: boolean;
+  includesNull: boolean;
+  includesNumber: boolean;
+  includesString: boolean;
+  includesUndefined: boolean;
+} | undefined {
+  const boundaryKinds = getHostTaggedBoundaryKinds(type);
+  if (boundaryKinds) {
+    return boundaryKinds;
+  }
+  if ((type.flags & ts.TypeFlags.NumberLike) !== 0) {
+    return {
+      includesBoolean: false,
+      includesNull: false,
+      includesNumber: true,
+      includesString: false,
+      includesUndefined: false,
+    };
+  }
+  if ((type.flags & ts.TypeFlags.BooleanLike) !== 0) {
+    return {
+      includesBoolean: true,
+      includesNull: false,
+      includesNumber: false,
+      includesString: false,
+      includesUndefined: false,
+    };
+  }
+  if (isStringLikeType(type)) {
+    return {
+      includesBoolean: false,
+      includesNull: false,
+      includesNumber: false,
+      includesString: true,
+      includesUndefined: false,
+    };
+  }
+  if (isUndefinedType(type)) {
+    return {
+      includesBoolean: false,
+      includesNull: false,
+      includesNumber: false,
+      includesString: false,
+      includesUndefined: true,
+    };
+  }
+  if (isNullType(type)) {
+    return {
+      includesBoolean: false,
+      includesNull: true,
+      includesNumber: false,
+      includesString: false,
+      includesUndefined: false,
+    };
+  }
+  return undefined;
+}
+
+export function getSupportedOwnedTaggedArrayKinds(
+  checker: ts.TypeChecker,
+  type: ts.Type,
+): {
+  includesBoolean: boolean;
+  includesNull: boolean;
+  includesNumber: boolean;
+  includesString: boolean;
+  includesUndefined: boolean;
+} | undefined {
+  if (isSupportedOwnedStringArrayType(checker, type) || isSupportedOwnedNumberArrayType(checker, type) ||
+    isSupportedOwnedBooleanArrayType(checker, type)) {
+    return undefined;
+  }
+  if ((type.flags & ts.TypeFlags.Object) === 0) {
+    return undefined;
+  }
+  const elementTypes = checker.isArrayType(type) || checker.isTupleType(type)
+    ? checker.getTypeArguments(type as ts.TypeReference)
+    : undefined;
+  if (!elementTypes || elementTypes.length === 0) {
+    return undefined;
+  }
+  const merged = {
+    includesBoolean: false,
+    includesNull: false,
+    includesNumber: false,
+    includesString: false,
+    includesUndefined: false,
+  };
+  for (const elementType of elementTypes) {
+    const kinds = getTaggedArrayElementKinds(elementType);
+    if (!kinds) {
+      return undefined;
+    }
+    merged.includesBoolean ||= kinds.includesBoolean;
+    merged.includesNull ||= kinds.includesNull;
+    merged.includesNumber ||= kinds.includesNumber;
+    merged.includesString ||= kinds.includesString;
+    merged.includesUndefined ||= kinds.includesUndefined;
+  }
+  return merged.includesBoolean || merged.includesNull || merged.includesNumber ||
+      merged.includesString || merged.includesUndefined
+    ? merged
+    : undefined;
+}
+
+export function isSupportedOwnedTaggedArrayType(checker: ts.TypeChecker, type: ts.Type): boolean {
+  return getSupportedOwnedTaggedArrayKinds(checker, type) !== undefined;
+}

package/project-transform/src/compiler/lower_strings.js

@@ -0,0 +1,121 @@
+import ts from 'typescript';
+import { isStringLikeType } from './lower_tagged.js';
+function isObjectConstructorReference(expression) {
+    return (ts.isIdentifier(expression) &&
+        expression.text === 'Object') || (ts.isPropertyAccessExpression(expression) &&
+        ts.isIdentifier(expression.expression) &&
+        expression.expression.text === 'globalThis' &&
+        expression.name.text === 'Object');
+}
+export function isObjectKeysCall(expression) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        isObjectConstructorReference(expression.expression.expression) &&
+        expression.expression.name.text === 'keys';
+}
+export function isObjectHasOwnCall(expression) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        isObjectConstructorReference(expression.expression.expression) &&
+        expression.expression.name.text === 'hasOwn';
+}
+export function isObjectValuesCall(expression) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        isObjectConstructorReference(expression.expression.expression) &&
+        expression.expression.name.text === 'values';
+}
+export function isObjectEntriesCall(expression) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        isObjectConstructorReference(expression.expression.expression) &&
+        expression.expression.name.text === 'entries';
+}
+export function isObjectAssignCall(expression) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        isObjectConstructorReference(expression.expression.expression) &&
+        expression.expression.name.text === 'assign';
+}
+export function isObjectFromEntriesCall(expression) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        isObjectConstructorReference(expression.expression.expression) &&
+        expression.expression.name.text === 'fromEntries';
+}
+export function isStringConstructorCall(expression) {
+    return (ts.isIdentifier(expression.expression) &&
+        expression.expression.text === 'String') || (ts.isPropertyAccessExpression(expression.expression) &&
+        ts.isIdentifier(expression.expression.expression) &&
+        expression.expression.expression.text === 'globalThis' &&
+        expression.expression.name.text === 'String');
+}
+export function isStringCharCodeAtCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'charCodeAt' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringToUpperCaseCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'toUpperCase' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringToLowerCaseCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'toLowerCase' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringTrimCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'trim' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringTrimStartCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'trimStart' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringTrimEndCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'trimEnd' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringStartsWithCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'startsWith' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringEndsWithCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'endsWith' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringIncludesCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'includes' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringIndexOfCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'indexOf' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringLastIndexOfCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'lastIndexOf' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringSliceCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'slice' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringSubstringCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'substring' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringCharAtCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'charAt' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+export function isStringCodePointAtCall(expression, checker) {
+    return ts.isPropertyAccessExpression(expression.expression) &&
+        expression.expression.name.text === 'codePointAt' &&
+        isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}

package/project-transform/src/compiler/lower_strings.ts

@@ -0,0 +1,198 @@
+import ts from 'typescript';
+
+import { isStringLikeType } from './lower_tagged.ts';
+
+function isObjectConstructorReference(expression: ts.Expression): boolean {
+  return (
+    ts.isIdentifier(expression) &&
+    expression.text === 'Object'
+  ) || (
+    ts.isPropertyAccessExpression(expression) &&
+    ts.isIdentifier(expression.expression) &&
+    expression.expression.text === 'globalThis' &&
+    expression.name.text === 'Object'
+  );
+}
+
+export function isObjectKeysCall(expression: ts.CallExpression): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    isObjectConstructorReference(expression.expression.expression) &&
+    expression.expression.name.text === 'keys';
+}
+
+export function isObjectHasOwnCall(expression: ts.CallExpression): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    isObjectConstructorReference(expression.expression.expression) &&
+    expression.expression.name.text === 'hasOwn';
+}
+
+export function isObjectValuesCall(expression: ts.CallExpression): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    isObjectConstructorReference(expression.expression.expression) &&
+    expression.expression.name.text === 'values';
+}
+
+export function isObjectEntriesCall(expression: ts.CallExpression): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    isObjectConstructorReference(expression.expression.expression) &&
+    expression.expression.name.text === 'entries';
+}
+
+export function isObjectAssignCall(expression: ts.CallExpression): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    isObjectConstructorReference(expression.expression.expression) &&
+    expression.expression.name.text === 'assign';
+}
+
+export function isObjectFromEntriesCall(expression: ts.CallExpression): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    isObjectConstructorReference(expression.expression.expression) &&
+    expression.expression.name.text === 'fromEntries';
+}
+
+export function isStringConstructorCall(expression: ts.CallExpression): boolean {
+  return (
+    ts.isIdentifier(expression.expression) &&
+    expression.expression.text === 'String'
+  ) || (
+    ts.isPropertyAccessExpression(expression.expression) &&
+    ts.isIdentifier(expression.expression.expression) &&
+    expression.expression.expression.text === 'globalThis' &&
+    expression.expression.name.text === 'String'
+  );
+}
+
+export function isStringCharCodeAtCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'charCodeAt' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringToUpperCaseCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'toUpperCase' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringToLowerCaseCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'toLowerCase' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringTrimCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'trim' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringTrimStartCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'trimStart' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringTrimEndCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'trimEnd' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringStartsWithCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'startsWith' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringEndsWithCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'endsWith' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringIncludesCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'includes' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringIndexOfCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'indexOf' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringLastIndexOfCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'lastIndexOf' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringSliceCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'slice' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringSubstringCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'substring' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringCharAtCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'charAt' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}
+
+export function isStringCodePointAtCall(
+  expression: ts.CallExpression,
+  checker: ts.TypeChecker,
+): boolean {
+  return ts.isPropertyAccessExpression(expression.expression) &&
+    expression.expression.name.text === 'codePointAt' &&
+    isStringLikeType(checker.getTypeAtLocation(expression.expression.expression));
+}