tree ae03127c8a47181e29e5f1714381b779895468aa
parent 353a730886364f1fa1987c6f2c4d924ec602c8aa
author Tint team <no-reply@google.com> 1673350765 +0000
committer Tint LUCI CQ <tint-scoped@luci-project-accounts.iam.gserviceaccount.com> 1673350765 +0000

Import Tint changes from Dawn

Changes:
  - 477744b7b52c0402e970b203431a5fbc305b4da4 Tint/GLSL: fix null ptr deref in Texture1D -> 2D. by senorblanco@chromium.org <Stephen White>
  - f7beb85fd10ae1a9493cd83df27fad07203012ba Count the line pos, offset and size of compilation messag... by Jiawei Shao <jiawei.shao@intel.com>
  - 2dfd177009b14650d67697b25f291dceb18d96d1 spirv-reader: Apply image coord vector check on unwrapped... by Arman Uguray <armansito@google.com>
GitOrigin-RevId: 477744b7b52c0402e970b203431a5fbc305b4da4
Change-Id: I3da91528ea74f26d1ea0518eee1eec390f86851c
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/116559
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
