Merge upstream main into 1600

SQLAlchemy mapped-column inference overlapped with callable-kind and shaped-array cleanup. Retain only the new mapped-column identity and type-alias support while adopting main's current IntTuple-based shape imports.

Author: asukaminato0721

.cargo/config.toml

@@ -10,4 +10,4 @@ MARSHMALLOW_TEST_PATH = { value = "pyrefly/lib/test/marshmallow/third-party", re
 GLEAN_SNAPSHOTS_PATH = { value = "pyrefly/lib/report/glean/snapshots", relative = true }
 COVERAGE_TEST_PATH = { value = "pyrefly/lib/test/coverage/test_files", relative = true }
 STUBGEN_TEST_PATH = { value = "pyrefly/lib/test/stubgen", relative = true }
-SHAPE_DSL_TEST_PATH = { value = "tensor-shapes", relative = true }
+SHAPE_EXTENSIONS_TEST_PATH = { value = "tensor-shapes/pyrefly-shape-extensions", relative = true }

.claude/skills/modify-shaped-array-dsl/SKILL.md

@@ -38,6 +38,15 @@ live in **one file**, `crates/pyrefly_types/src/meta_shape_dsl.rs` (the binop
 arithmetic is `eval_binop`); the symbolic dim algebra it calls
 (`SizeExpr::add/sub/mul/floor_div`) is in `crates/pyrefly_types/src/dimension.rs`.
 
+### Preserve tensor types in numeric formulas
+
+Integer/float arithmetic overloads can sometimes cause a tensor expression to
+lose type information during overload selection. In tensor code, make formulas
+explicitly floating-point when the result is intended to remain a tensor. For
+example, multiply an exponent by `1.0`, or use a floating-point base such as
+`2.0` instead of `2`. These equivalent forms steer overload selection toward
+floating-point tensor arithmetic.
+
 ## You MUST unit-test the DSL logic, not just an example
 
 An end-to-end example (`tensor-shapes/pyrefly-torch-stubs/examples`) exercises an op but does
@@ -61,6 +70,19 @@ After a DSL-kernel (Rust) change you must rebuild before the checker sees it:
 `buck build fbcode//pyrefly:pyrefly` (or `cargo build`). Stub-only `_shapes.pyi`
 edits need no rebuild.
 
+For any DSL-kernel or broader Pyrefly core change that modifies shape
+manipulation semantics (as opposed to only editing torch/numpy stubs), the
+default verification gate is:
+
+```bash
+tensor-shapes/run_all_shape_tests.py
+```
+
+This gate runs the shape-relevant Rust unit tests plus the non-runtime
+tensor-shape corpus tests, and defaults to cargo with automatic buck fallback.
+Use `--mode buck` or `--mode cargo` when you need to pin the backend, and add
+`--include-runtime-tests` only when runtime coverage is relevant.
+
 ## Contributing the change
 
 - **fbsource**: land as a diff.

.github/owners.json

@@ -0,0 +1,14 @@
+[
+  "yangdanny97",
+  "grievejia",
+  "stroxler",
+  "kinto0",
+  "samwgoldman",
+  "rchen152",
+  "lolpack",
+  "connernilsen",
+  "maggiemoss",
+  "javabster",
+  "ndmitchell",
+  "nathantempest"
+]

.github/workflows/assign_importer.yml

@@ -0,0 +1,65 @@
+name: Assign imported PR to importer
+
+on:
+  issue_comment:
+    types: [created]
+
+permissions: {}
+
+jobs:
+  assign-importer:
+    # issue_comment fires for both issues and PRs. Only act on PRs, and only on
+    # the import bot's comment that records who imported the PR to Phabricator.
+    # Gating on the bot author is also the security boundary: it stops an
+    # arbitrary commenter from spoofing an "imported" notice to assign someone.
+    if: >-
+      ${{ github.event.issue.pull_request != null
+          && github.event.comment.user.login == 'meta-codesync[bot]' }}
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Assign the importer named in the import comment
+        uses: actions/github-script@v8
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            // meta-codesync[bot] posts "@<handle> has **imported** this pull
+            // request. ..." when a Meta employee imports the PR to Phabricator.
+            // "imported" is bold in the raw markdown, so tolerate the "**". The
+            // named importer is always a Meta employee, so there is no allowlist
+            // to check — the bot-author gate above is the trust boundary, and
+            // the verify step below drops anyone lacking repo access.
+            const body = context.payload.comment.body || '';
+            const match = body.match(/@([A-Za-z0-9-]+) has \**imported\** this pull request/);
+            if (!match) {
+              console.log('Comment is not an import notice, skipping');
+              return;
+            }
+            const importer = match[1];
+
+            const issue_number = context.payload.issue.number;
+            const { owner, repo } = context.repo;
+            const assignees = (context.payload.issue.assignees || []).map(a => a.login);
+
+            if (assignees.includes(importer)) {
+              console.log(`${importer} is already assigned to #${issue_number}`);
+              return;
+            }
+            // Respect an existing manual assignment rather than clobbering it.
+            if (assignees.length > 0) {
+              console.log(`#${issue_number} already assigned to ${assignees.join(', ')}, leaving as-is`);
+              return;
+            }
+
+            await github.rest.issues.addAssignees({ owner, repo, issue_number, assignees: [importer] });
+
+            // GitHub silently ignores assignees who lack repo access, so verify
+            // the assignment actually took effect.
+            const { data: pr } = await github.rest.issues.get({ owner, repo, issue_number });
+            if (!(pr.assignees || []).some(a => a.login === importer)) {
+              console.log(`Could not assign ${importer} to #${issue_number} (no repo access?)`);
+              return;
+            }
+
+            console.log(`Assigned importer ${importer} to #${issue_number}`);

.github/workflows/assign_owners_nightly.yml

@@ -0,0 +1,234 @@
+name: Nightly assign team owners to unassigned PRs
+
+# Nightly sweep that assigns a Pyrefly team engineer (from .github/owners.json)
+# to open PRs that have no assignee, no merge conflict, and a signed CLA — the
+# PRs that are ready for a team member to shepherd but nobody has picked up.
+# Same logic as the on-demand backfill (assign_owners_sweep.yml), but runs
+# automatically once a day so newly-eligible PRs get picked up without anyone
+# having to trigger it.
+#
+# Selection is least-loaded (balanced against each owner's current open-PR
+# backlog). The picked owner is both assigned and requested as a reviewer (so
+# the PR shows up in their review queue), and each assignment is announced in
+# the team Discord channel.
+#
+# Scheduled runs assign for real.
+# Scheduled runs assign for real. A manual run from the Actions tab exposes a
+# "dry_run" toggle (default off) to preview without assigning.
+
+on:
+  schedule:
+    - cron: "0 9 * * *"
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: "Only log what would be assigned/notified, without assigning"
+        type: boolean
+        default: false
+
+permissions: {}
+
+jobs:
+  assign-owners:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read # read owners.json
+      checks: read # read the Meta CLA check run
+      issues: write # addAssignees is the issues API
+      pull-requests: write
+    steps:
+      - name: Assign least-loaded owner to eligible open PRs
+        uses: actions/github-script@v8
+        env:
+          DISCORD_WEBHOOK: ${{ secrets.DISCORD_ASSIGNMENTS_WEBHOOK_URL }}
+          DISCORD_IDS: ${{ secrets.DISCORD_ASSIGNMENT_IDS }}
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            // Scheduled runs have no inputs and always assign for real; a manual
+            // run assigns unless its dry_run toggle is explicitly checked.
+            const dryRun = (context.payload.inputs && context.payload.inputs.dry_run) === 'true';
+            const { owner, repo } = context.repo;
+
+            // Pyrefly team GitHub handles — single source of truth in
+            // .github/owners.json. Lower-cased for case-insensitive matching.
+            const ownersFile = await github.rest.repos.getContent({
+              owner, repo, path: '.github/owners.json',
+            });
+            const owners = JSON.parse(
+              Buffer.from(ownersFile.data.content, 'base64').toString('utf8'),
+            ).map((o) => o.toLowerCase());
+            if (owners.length === 0) {
+              console.log('owners.json is empty, nothing to assign');
+              return;
+            }
+
+            // Round-robin pool = owners minus intentionally non-assignable
+            // members: managers, hands-off maintainers, and anyone not
+            // responsible for reviewing PRs. They stay in owners.json (still
+            // team members for auto_assign.yml) but never receive sweep
+            // assignments.
+            const NOT_ASSIGNABLE = new Set(['lolpack', 'ndmitchell', 'javabster', 'yangdanny97']);
+            const assignable = owners.filter((o) => !NOT_ASSIGNABLE.has(o));
+            if (assignable.length === 0) {
+              console.log('No assignable owners after exclusions, nothing to assign');
+              return;
+            }
+
+            // GitHub-handle -> numeric Discord user ID map for @-mentions. Kept
+            // in the DISCORD_ASSIGNMENT_IDS secret, not a committed file: these
+            // are personal Discord IDs and pyrefly is a public repo. An unset or
+            // malformed secret means no one is pinged (posts are skipped).
+            let discordIds = {};
+            try {
+              discordIds = JSON.parse(process.env.DISCORD_IDS || '{}');
+            } catch (e) {
+              console.log('DISCORD_ASSIGNMENT_IDS secret is not valid JSON; Discord posts will be skipped');
+            }
+
+            const prs = await github.paginate(github.rest.pulls.list, {
+              owner, repo, state: 'open', per_page: 100,
+            });
+
+            // Seed per-owner load from PRs already assigned to each assignable
+            // owner so least-loaded balances against the standing backlog, not
+            // just this run's picks.
+            const load = new Map(assignable.map((o) => [o, 0]));
+            for (const pr of prs) {
+              for (const a of pr.assignees || []) {
+                const key = a.login.toLowerCase();
+                if (load.has(key)) load.set(key, load.get(key) + 1);
+              }
+            }
+
+            // The CLA gate is a completed "meta-cla" check run on the PR head
+            // SHA: conclusion "success" once signed, "action_required" while
+            // unsigned. It is a check run, not a commit status. Use the newest
+            // meta-cla run (re-runs append), falling back to a name match.
+            const isClaSigned = async (sha) => {
+              const checks = await github.paginate(github.rest.checks.listForRef, {
+                owner, repo, ref: sha, per_page: 100,
+              });
+              const cla = checks
+                .filter((c) => (c.app && c.app.slug === 'meta-cla') || /cla/i.test(c.name))
+                .sort((a, b) => new Date(b.started_at || 0) - new Date(a.started_at || 0));
+              return cla.length > 0 && cla[0].conclusion === 'success';
+            };
+
+            // pulls.list omits mergeability; fetch the PR for it. GitHub computes
+            // it asynchronously, so `mergeable` can be null right after a push —
+            // re-fetch once, then treat a still-unknown result as "skip" rather
+            // than risk assigning a conflicted PR. A true conflict is
+            // mergeable === false / mergeable_state "dirty"; "blocked" (awaiting
+            // checks/CLA/review) is NOT a conflict and must not be excluded.
+            const hasNoConflict = async (number) => {
+              for (let attempt = 0; attempt < 2; attempt++) {
+                const { data: pr } = await github.rest.pulls.get({ owner, repo, pull_number: number });
+                if (pr.mergeable !== null) {
+                  return pr.mergeable === true && pr.mergeable_state !== 'dirty';
+                }
+                await new Promise((r) => setTimeout(r, 3000));
+              }
+              console.log(`#${number}: mergeability still unknown, skipping`);
+              return false;
+            };
+
+            // Discord embeds don't fire mentions, so the @-mention goes in the
+            // top-level content while the embed carries the PR title/link
+            // (matching notify_discord_prs.yml). A real mention needs the numeric
+            // Discord user ID; without one we can't ping the assignee, so we log
+            // and skip the post rather than sending a name that notifies nobody.
+            const notify = async (assignee, pr) => {
+              const discordId = discordIds[assignee];
+              if (!discordId) {
+                console.log(`#${pr.number}: no Discord ID mapped for ${assignee}, skipping Discord post`);
+                return;
+              }
+              const title = `Assigned to Pyrefly PR #${pr.number}: ${pr.title}`;
+              const truncatedTitle = title.length > 256 ? `${title.substring(0, 253)}...` : title;
+              const payload = {
+                content: `<@${discordId}> you've been assigned a PR to shepherd:`,
+                embeds: [{
+                  title: truncatedTitle,
+                  url: pr.html_url,
+                  color: 16744448,
+                  fields: [{
+                    name: 'Assignee',
+                    value: `[${assignee}](https://github.com/${assignee})`,
+                    inline: true,
+                  }],
+                }],
+              };
+              if (dryRun) {
+                console.log(`[dry-run] would post to Discord: ${JSON.stringify(payload)}`);
+                return;
+              }
+              const webhook = process.env.DISCORD_WEBHOOK;
+              if (!webhook) {
+                console.log('DISCORD_ASSIGNMENTS_WEBHOOK_URL secret not set, skipping notification');
+                return;
+              }
+              const res = await fetch(webhook, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+              });
+              if (!res.ok) {
+                console.log(`Discord POST failed for #${pr.number}: ${res.status} ${await res.text()}`);
+              }
+            };
+
+            let assigned = 0;
+            for (const pr of prs) {
+              if ((pr.assignees || []).length > 0) continue;
+              if (pr.draft) continue; // drafts aren't ready for a shepherd yet
+
+              if (!(await isClaSigned(pr.head.sha))) {
+                console.log(`#${pr.number}: CLA not signed, skipping`);
+                continue;
+              }
+              if (!(await hasNoConflict(pr.number))) {
+                console.log(`#${pr.number}: merge conflict / unknown mergeability, skipping`);
+                continue;
+              }
+
+              // Least-loaded assignable owner; ties break by owners.json order.
+              const pick = assignable.reduce(
+                (best, o) => (load.get(o) < load.get(best) ? o : best),
+                assignable[0],
+              );
+
+              if (!dryRun) {
+                await github.rest.issues.addAssignees({
+                  owner, repo, issue_number: pr.number, assignees: [pick],
+                });
+                // GitHub silently drops assignees lacking repo access, so verify.
+                const { data: after } = await github.rest.issues.get({ owner, repo, issue_number: pr.number });
+                if (!(after.assignees || []).some((a) => a.login.toLowerCase() === pick)) {
+                  console.log(`#${pr.number}: could not assign ${pick} (no repo access?)`);
+                  continue;
+                }
+                // Also request them as a reviewer so the PR lands in their review
+                // queue, not just their assigned list. GitHub rejects requesting
+                // review from the PR author (422), so skip that case; a failure
+                // here must not undo the assignment we just verified.
+                if (pr.user.login.toLowerCase() === pick) {
+                  console.log(`#${pr.number}: ${pick} is the PR author, skipping review request`);
+                } else {
+                  try {
+                    await github.rest.pulls.requestReviewers({
+                      owner, repo, pull_number: pr.number, reviewers: [pick],
+                    });
+                  } catch (e) {
+                    console.log(`#${pr.number}: could not request review from ${pick}: ${e.message}`);
+                  }
+                }
+              }
+
+              load.set(pick, load.get(pick) + 1);
+              console.log(`${dryRun ? '[dry-run] would assign + request review from' : '#' + pr.number + ': assigned + requested review from'} ${pick}${dryRun ? ` to #${pr.number}` : ''} (load now ${load.get(pick)})`);
+              await notify(pick, pr);
+              assigned++;
+            }
+
+            console.log(`Scanned ${prs.length} open PRs. ${dryRun ? 'Would assign' : 'Assigned'}: ${assigned}.`);