chore: use explicit matcher call context

Author: pavelfeldman

packages/playwright/src/matchers/expect.ts

@@ -141,17 +141,7 @@ function createExpect(info: ExpectMetaInfo, prefix: string[], customMatchers: Re
           const wrappedMatchers: any = {};
           const extendedMatchers: any = { ...customMatchers };
           for (const [name, matcher] of Object.entries(matchers)) {
-            wrappedMatchers[name] = function(...args: any[]) {
-              const { isNot, promise, utils } = this;
-              const newThis: ExpectMatcherState = {
-                isNot,
-                promise,
-                utils,
-                timeout: currentExpectTimeout()
-              };
-              (newThis as any).equals = throwUnsupportedExpectMatcherError;
-              return (matcher as any).call(newThis, ...args);
-            };
+            wrappedMatchers[name] = wrapPlaywrightMatcherToPassNiceThis(matcher);
             const key = qualifiedMatcherName(qualifier, name);
             wrappedMatchers[key] = wrappedMatchers[name];
             Object.defineProperty(wrappedMatchers[key], 'name', { value: name });
@@ -203,6 +193,47 @@ function createExpect(info: ExpectMetaInfo, prefix: string[], customMatchers: Re
   return expectInstance;
 }
 
+// Expect wraps matchers, so there is no way to pass this information to the raw Playwright matcher.
+// Rely on sync call sequence to seed each matcher call with the context.
+type MatcherCallContext = {
+  expectInfo: ExpectMetaInfo;
+  testInfo: TestInfoImpl | null;
+};
+
+let matcherCallContext: MatcherCallContext | undefined;
+
+function setMatcherCallContext(context: MatcherCallContext) {
+  matcherCallContext = context;
+}
+
+function getMatcherCallContext(): MatcherCallContext {
+  // TODO: re-implement to allow for "take" semantics.
+  return matcherCallContext!;
+}
+
+type ExpectMatcherStateInternal = ExpectMatcherState & {
+  _context: MatcherCallContext | undefined;
+};
+
+const defaultExpectTimeout = 5000;
+
+function wrapPlaywrightMatcherToPassNiceThis(matcher: any) {
+  return function(this: any, ...args: any[]) {
+    const { isNot, promise, utils } = this;
+    const context = getMatcherCallContext();
+    const timeout = context.expectInfo.timeout ?? context?.testInfo?._projectInternal?.expect?.timeout ?? defaultExpectTimeout;
+    const newThis: ExpectMatcherStateInternal = {
+      isNot,
+      promise,
+      utils,
+      timeout,
+      _context: context,
+    };
+    (newThis as any).equals = throwUnsupportedExpectMatcherError;
+    return matcher.call(newThis, ...args);
+  };
+}
+
 function throwUnsupportedExpectMatcherError() {
   throw new Error('It looks like you are using custom expect matchers that are not compatible with Playwright. See https://aka.ms/playwright/expect-compatibility');
 }
@@ -299,8 +330,7 @@ class ExpectMetaInfoProxyHandler implements ProxyHandler<any> {
     }
     return (...args: any[]) => {
       const testInfo = currentTestInfo();
-      // We assume that the matcher will read the current expect timeout the first thing.
-      setCurrentExpectConfigureTimeout(this._info.timeout);
+      setMatcherCallContext({ expectInfo: this._info, testInfo });
       if (!testInfo)
         return matcher.call(target, ...args);
 
@@ -362,7 +392,7 @@ class ExpectMetaInfoProxyHandler implements ProxyHandler<any> {
 async function pollMatcher(qualifiedMatcherName: string, info: ExpectMetaInfo, prefix: string[], ...args: any[]) {
   const testInfo = currentTestInfo();
   const poll = info.poll!;
-  const timeout = poll.timeout ?? currentExpectTimeout();
+  const timeout = poll.timeout ?? info.timeout ?? testInfo?._projectInternal?.expect?.timeout ?? defaultExpectTimeout;
   const { deadline, timeoutMessage } = testInfo ? testInfo._deadlineForMatcher(timeout) : TestInfoImpl._defaultDeadlineForMatcher(timeout);
 
   const result = await pollAgainstDeadline<Error|undefined>(async () => {
@@ -379,6 +409,7 @@ async function pollMatcher(qualifiedMatcherName: string, info: ExpectMetaInfo, p
       let matchers = createMatchers(value, innerInfo, prefix);
       if (info.isNot)
         matchers = matchers.not;
+      setMatcherCallContext({ expectInfo: info, testInfo });
       matchers[qualifiedMatcherName](...args);
       return { continuePolling: false, result: undefined };
     } catch (error) {
@@ -398,22 +429,6 @@ async function pollMatcher(qualifiedMatcherName: string, info: ExpectMetaInfo, p
   }
 }
 
-let currentExpectConfigureTimeout: number | undefined;
-
-function setCurrentExpectConfigureTimeout(timeout: number | undefined) {
-  currentExpectConfigureTimeout = timeout;
-}
-
-function currentExpectTimeout() {
-  if (currentExpectConfigureTimeout !== undefined)
-    return currentExpectConfigureTimeout;
-  const testInfo = currentTestInfo();
-  let defaultExpectTimeout = testInfo?._projectInternal?.expect?.timeout;
-  if (typeof defaultExpectTimeout === 'undefined')
-    defaultExpectTimeout = 5000;
-  return defaultExpectTimeout;
-}
-
 function computeArgsSuffix(matcherName: string, args: any[]) {
   let value = '';
   if (matcherName === 'toHaveScreenshot')