diff --git a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
index 6cbaec6..f1bd0c3 100644
--- a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
+++ b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
@@ -174,6 +174,12 @@
 
             // Replace the original texture_external binding with a texture_2d<f32> binding.
             auto cloned_attributes = ctx.Clone(global->attributes);
+
+            // Allow the originating binding to have collisions.
+            if (new_binding_points->allow_collisions) {
+                cloned_attributes.Push(b.Disable(DisabledValidation::kBindingPointCollision));
+            }
+
             const Expression* cloned_initializer = ctx.Clone(global->initializer);
 
             auto* replacement = b.Var(
diff --git a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture_test.cc b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture_test.cc
index 27f2acb..f89523c 100644
--- a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture_test.cc
+++ b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture_test.cc
@@ -176,6 +176,83 @@
     EXPECT_EQ(expect, str(got));
 }
 
+TEST_F(MultiplanarExternalTextureTest, Collisions) {
+    auto* src = R"(
+@group(0) @binding(0) var myTexture: texture_external;
+
+@fragment
+fn fragmentMain() -> @location(0) vec4f {
+  let result = textureLoad(myTexture, vec2u(1, 1));
+  return vec4f(1);
+})";
+
+    auto* expect = R"(
+struct GammaTransferParams {
+  G : f32,
+  A : f32,
+  B : f32,
+  C : f32,
+  D : f32,
+  E : f32,
+  F : f32,
+  padding : u32,
+}
+
+struct ExternalTextureParams {
+  numPlanes : u32,
+  doYuvToRgbConversionOnly : u32,
+  yuvToRgbConversionMatrix : mat3x4<f32>,
+  gammaDecodeParams : GammaTransferParams,
+  gammaEncodeParams : GammaTransferParams,
+  gamutConversionMatrix : mat3x3<f32>,
+  coordTransformationMatrix : mat3x2<f32>,
+}
+
+@internal(disable_validation__binding_point_collision) @group(0) @binding(1) var ext_tex_plane_1 : texture_2d<f32>;
+
+@internal(disable_validation__binding_point_collision) @group(0) @binding(0) var<uniform> ext_tex_params : ExternalTextureParams;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var myTexture : texture_2d<f32>;
+
+fn gammaCorrection(v : vec3<f32>, params : GammaTransferParams) -> vec3<f32> {
+  let cond = (abs(v) < vec3<f32>(params.D));
+  let t = (sign(v) * ((params.C * abs(v)) + params.F));
+  let f = (sign(v) * (pow(((params.A * abs(v)) + params.B), vec3<f32>(params.G)) + params.E));
+  return select(f, t, cond);
+}
+
+fn textureLoadExternal(plane0 : texture_2d<f32>, plane1 : texture_2d<f32>, coord : vec2<u32>, params : ExternalTextureParams) -> vec4<f32> {
+  let coord1 = (coord >> vec2<u32>(1));
+  var color : vec4<f32>;
+  if ((params.numPlanes == 1)) {
+    color = textureLoad(plane0, coord, 0).rgba;
+  } else {
+    color = vec4<f32>((vec4<f32>(textureLoad(plane0, coord, 0).r, textureLoad(plane1, coord1, 0).rg, 1) * params.yuvToRgbConversionMatrix), 1);
+  }
+  if ((params.doYuvToRgbConversionOnly == 0)) {
+    color = vec4<f32>(gammaCorrection(color.rgb, params.gammaDecodeParams), color.a);
+    color = vec4<f32>((params.gamutConversionMatrix * color.rgb), color.a);
+    color = vec4<f32>(gammaCorrection(color.rgb, params.gammaEncodeParams), color.a);
+  }
+  return color;
+}
+
+@fragment
+fn fragmentMain() -> @location(0) vec4f {
+  let result = textureLoadExternal(myTexture, ext_tex_plane_1, vec2u(1, 1), ext_tex_params);
+  return vec4f(1);
+}
+)";
+
+    DataMap data;
+    data.Add<MultiplanarExternalTexture::NewBindingPoints>(
+        MultiplanarExternalTexture::BindingsMap{{{0, 0}, {{0, 1}, {0, 0}}}},
+        /* allow collisions */ true);
+    auto got = Run<MultiplanarExternalTexture>(src, data);
+
+    EXPECT_EQ(expect, str(got));
+}
+
 // Tests that the transform works with a textureDimensions call.
 TEST_F(MultiplanarExternalTextureTest, Dimensions_OutOfOrder) {
     auto* src = R"(
diff --git a/src/tint/lang/wgsl/ls/file.h b/src/tint/lang/wgsl/ls/file.h
index 7e6c367..7f31ad9 100644
--- a/src/tint/lang/wgsl/ls/file.h
+++ b/src/tint/lang/wgsl/ls/file.h
@@ -28,6 +28,8 @@
 #ifndef SRC_TINT_LANG_WGSL_LS_FILE_H_
 #define SRC_TINT_LANG_WGSL_LS_FILE_H_
 
+#include <cstddef>
+#include <cstdint>
 #include <limits>
 #include <memory>
 #include <string>
@@ -98,17 +100,16 @@
     template <typename T = sem::Node, UnwrapMode UNWRAP_MODE = DefaultUnwrapMode<T>>
     const T* NodeAt(Source::Location l) const {
         // TODO(bclayton): This is a brute-force search. Optimize.
-        size_t best_len = std::numeric_limits<uint32_t>::max();
+        size_t best_len = std::numeric_limits<size_t>::max();
         const T* best_node = nullptr;
         for (auto* node : nodes) {
-            if (node->source.range.begin.line == node->source.range.end.line &&
-                node->source.range.begin <= l && node->source.range.end >= l) {
+            if (node->source.range.begin <= l && node->source.range.end >= l) {
                 auto* sem = program.Sem().Get(node);
                 if constexpr (UNWRAP_MODE == UnwrapMode::kUnwrap) {
                     sem = Unwrap(sem);
                 }
                 if (auto* cast = As<T, CastFlags::kDontErrorOnImpossibleCast>(sem)) {
-                    size_t len = node->source.range.end.column - node->source.range.begin.column;
+                    size_t len = node->source.range.Length(source->content);
                     if (len < best_len) {
                         best_len = len;
                         best_node = cast;
diff --git a/src/tint/lang/wgsl/ls/hover.cc b/src/tint/lang/wgsl/ls/hover.cc
index 5ffbe47..fe9f123 100644
--- a/src/tint/lang/wgsl/ls/hover.cc
+++ b/src/tint/lang/wgsl/ls/hover.cc
@@ -64,6 +64,7 @@
 
 namespace {
 
+/// @returns a lsp::MarkedStringWithLanguage with the content @p wgsl, using the language `wgsl`
 lsp::MarkedStringWithLanguage WGSL(std::string wgsl) {
     lsp::MarkedStringWithLanguage str;
     str.language = "wgsl";
@@ -71,6 +72,7 @@
     return str;
 }
 
+/// PrintConstant() writes the constant value @p val as a WGSL value to the StringStream @p ss
 void PrintConstant(const core::constant::Value* val, StringStream& ss) {
     Switch(
         val,  //
@@ -98,6 +100,7 @@
         });
 }
 
+/// Variable() writes the hover information for the variable @p v to @p out
 void Variable(const sem::Variable* v, std::vector<lsp::MarkedString>& out) {
     StringStream ss;
     auto* kind = Switch(
@@ -122,6 +125,7 @@
     out.push_back(WGSL(ss.str()));
 }
 
+/// Function() writes the hover information for the function @p f to @p out
 void Function(const sem::Function* f, std::vector<lsp::MarkedString>& out) {
     StringStream ss;
     ss << "fn " << f->Declaration()->name->symbol.NameView();
@@ -142,6 +146,8 @@
     out.push_back(WGSL(ss.str()));
 }
 
+/// Call() writes the hover information for a call to the function with the name @p name with
+/// semantic info @p c, to @p out
 void Call(std::string_view name, const sem::Call* c, std::vector<lsp::MarkedString>& out) {
     StringStream ss;
     ss << name << "(";
@@ -165,6 +171,7 @@
     out.push_back(WGSL(ss.str()));
 }
 
+/// Constant() writes the hover information for the constant value @p val to @p out
 void Constant(const core::constant::Value* val, std::vector<lsp::MarkedString>& out) {
     StringStream ss;
     PrintConstant(val, ss);
diff --git a/src/tint/lang/wgsl/ls/sem_tokens.cc b/src/tint/lang/wgsl/ls/sem_tokens.cc
index 3accd26..ddbd5a5 100644
--- a/src/tint/lang/wgsl/ls/sem_tokens.cc
+++ b/src/tint/lang/wgsl/ls/sem_tokens.cc
@@ -50,12 +50,17 @@
 
 namespace {
 
+/// Token describes a single semantic token, as returned by TextDocumentSemanticTokensFullRequest.
 struct Token {
+    /// The start position of the token
     lsp::Position position;
+    /// The kind of token. Maps to enumerators in SemToken.
     size_t kind = 0;
+    /// The length of the token in UTF-8 codepoints.
     size_t length = 0;
 };
 
+/// @returns a Token built from the source range @p range with the kind @p kind
 Token TokenFromRange(const tint::Source::Range& range, SemToken::Kind kind) {
     Token tok;
     tok.position = Conv(range.begin);
@@ -64,6 +69,8 @@
     return tok;
 }
 
+/// @returns the token kind for the expression @p expr, or nullptr if the expression does not have a
+/// token kind.
 std::optional<SemToken::Kind> TokenKindFor(const sem::Expression* expr) {
     return Switch<std::optional<SemToken::Kind>>(
         Unwrap(expr),  //
@@ -75,6 +82,7 @@
         [](tint::Default) { return std::nullopt; });
 }
 
+/// @returns all the semantic tokens in the file @p file, in sequential order.
 std::vector<Token> Tokens(File& file) {
     std::vector<Token> tokens;
     auto& sem = file.program.Sem();
@@ -102,6 +110,9 @@
                 tokens.push_back(TokenFromRange(a->member->source.range, SemToken::kMember));
             });
     }
+    std::sort(tokens.begin(), tokens.end(),
+              [](const Token& a, const Token& b) { return a.position < b.position; });
+
     return tokens;
 }
 
@@ -117,9 +128,6 @@
         Token last;
 
         auto tokens = Tokens(**file);
-        std::sort(tokens.begin(), tokens.end(),
-                  [](const Token& a, const Token& b) { return a.position < b.position; });
-
         for (auto tok : tokens) {
             if (last.position.line != tok.position.line) {
                 last.position.character = 0;
diff --git a/src/tint/lang/wgsl/ls/signature_help.cc b/src/tint/lang/wgsl/ls/signature_help.cc
index 401e621..7644c74 100644
--- a/src/tint/lang/wgsl/ls/signature_help.cc
+++ b/src/tint/lang/wgsl/ls/signature_help.cc
@@ -27,6 +27,7 @@
 
 #include "src/tint/lang/wgsl/ls/server.h"
 
+#include "langsvr/lsp/comparators.h"
 #include "src/tint/lang/core/intrinsic/table.h"
 #include "src/tint/lang/wgsl/intrinsic/dialect.h"
 #include "src/tint/lang/wgsl/ls/utils.h"
@@ -40,8 +41,10 @@
 
 namespace {
 
-std::vector<lsp::ParameterInformation> Params(const core::intrinsic::TableData& data,
-                                              const core::intrinsic::OverloadInfo& overload) {
+/// @returns the parameter information for all the parameters of the intrinsic overload @p overload.
+std::vector<lsp::ParameterInformation> Params(const core::intrinsic::OverloadInfo& overload) {
+    auto& data = wgsl::intrinsic::Dialect::kData;
+
     std::vector<lsp::ParameterInformation> params;
     for (size_t i = 0; i < overload.num_parameters; i++) {
         lsp::ParameterInformation param_out;
@@ -56,18 +59,22 @@
     return params;
 }
 
-size_t CalcParamIndex(const Source& call_source, const Source::Location& carat) {
+/// @returns the zero-based index of the parameter at with the cursor at @p position, for a call
+/// with the source @p call_source.
+size_t CalcParamIndex(const Source& call_source, const Source::Location& position) {
     size_t index = 0;
     int depth = 0;
 
-    auto start = call_source.range.begin;
-    auto end = std::min(call_source.range.end, carat);
+    auto range = Conv(call_source.range);
+    auto start = range.start;
+    auto end = std::min(range.end, Conv(position));
     auto& lines = call_source.file->content.lines;
 
-    for (auto line = start.line; line <= end.line; line++) {
-        auto start_column = line == start.line ? start.column : 0;
-        auto end_column = line == end.line ? end.column : 0;
-        auto text = lines[line - 1].substr(start_column - 1, end_column - start_column);
+    for (auto line_idx = start.line; line_idx <= end.line; line_idx++) {
+        auto& line = lines[line_idx];
+        auto start_character = (line_idx == start.line) ? start.character : 0;
+        auto end_character = (line_idx == end.line) ? end.character : line.size();
+        auto text = line.substr(start_character, end_character - start_character);
         for (char c : text) {
             switch (c) {
                 case '(':
@@ -88,6 +95,8 @@
     return index;
 }
 
+/// PrintOverload() emits a description of the intrinsic overload @p overload of the function with
+/// name @p intrinsic_name to @p ss.
 void PrintOverload(StyledText& ss,
                    core::intrinsic::Context& context,
                    const core::intrinsic::OverloadInfo& overload,
@@ -187,7 +196,7 @@
                for (size_t i = 0; i < intrinsic_info.num_overloads; i++) {
                    auto& overload = data[intrinsic_info.overloads + i];
 
-                   auto params = Params(data, overload);
+                   auto params = Params(overload);
 
                    auto type_mgr = core::type::Manager::Wrap(program.Types());
                    auto symbols = SymbolTable::Wrap(program.Symbols());
diff --git a/src/tint/lang/wgsl/ls/signature_help_test.cc b/src/tint/lang/wgsl/ls/signature_help_test.cc
index ceaf52a..31fcaba 100644
--- a/src/tint/lang/wgsl/ls/signature_help_test.cc
+++ b/src/tint/lang/wgsl/ls/signature_help_test.cc
@@ -271,6 +271,28 @@
                              },  // =========================================
                              {
                                  R"(
+const C = max(1
+              ⧘
+              ,
+              2);
+)",
+                                 MaxSignatures(),
+                                 /* active_signature */ 0,
+                                 /* active_parameter */ 0,
+                             },  // =========================================
+                             {
+                                 R"(
+const C = max(1
+              ,
+              ⧘
+              2);
+)",
+                                 MaxSignatures(),
+                                 /* active_signature */ 0,
+                                 /* active_parameter */ 1,
+                             },  // =========================================
+                             {
+                                 R"(
 const C = max(1, 2) ⧘;
 )",
                                  {},
diff --git a/src/tint/utils/diagnostic/source.cc b/src/tint/utils/diagnostic/source.cc
index 3dc439b..b183f8a 100644
--- a/src/tint/utils/diagnostic/source.cc
+++ b/src/tint/utils/diagnostic/source.cc
@@ -31,6 +31,7 @@
 #include <string_view>
 #include <utility>
 
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/text/string_stream.h"
 #include "src/tint/utils/text/unicode.h"
 
@@ -190,4 +191,25 @@
     return out.str();
 }
 
+size_t Source::Range::Length(const FileContent& content) const {
+    TINT_ASSERT_OR_RETURN_VALUE(begin <= end, 0);
+    TINT_ASSERT_OR_RETURN_VALUE(begin.column > 0, 0);
+    TINT_ASSERT_OR_RETURN_VALUE(begin.line > 0, 0);
+    TINT_ASSERT_OR_RETURN_VALUE(end.line <= 1 + content.lines.size(), 0);
+    TINT_ASSERT_OR_RETURN_VALUE(end.column <= 1 + content.lines[end.line - 1].size(), 0);
+
+    if (end.line == begin.line) {
+        return end.column - begin.column;
+    }
+
+    size_t len = (content.lines[begin.line - 1].size() + 1 - begin.column) +  // first line
+                 (end.column - 1) +                                           // last line
+                 end.line - begin.line;                                       // newlines
+
+    for (size_t line = begin.line + 1; line < end.line; line++) {
+        len += content.lines[line - 1].size();  // whole-lines
+    }
+    return len;
+}
+
 }  // namespace tint
diff --git a/src/tint/utils/diagnostic/source.h b/src/tint/utils/diagnostic/source.h
index afef58c..e644122 100644
--- a/src/tint/utils/diagnostic/source.h
+++ b/src/tint/utils/diagnostic/source.h
@@ -42,7 +42,7 @@
 /// Source describes a range of characters within a source file.
 class Source {
   public:
-    /// FileContent describes the content of a source file encoded using utf-8.
+    /// FileContent describes the content of a source file encoded using UTF-8.
     class FileContent {
       public:
         /// Constructs the FileContent with the given file content.
@@ -151,7 +151,7 @@
         inline constexpr Range(const Location& b, const Location& e) : begin(b), end(e) {}
 
         /// Return a column-shifted Range
-        /// @param n the number of characters to shift by
+        /// @param n the number of UTF-8 codepoint to shift by
         /// @returns a Range with a #begin and #end column shifted by `n`
         inline Range operator+(uint32_t n) const {
             return Range{{begin.line, begin.column + n}, {end.line, end.column + n}};
@@ -169,9 +169,16 @@
         /// @returns true if `this` == `rhs`
         inline bool operator!=(const Range& rhs) const { return !(*this == rhs); }
 
-        /// The location of the first character in the range.
+        /// @param content the file content that this range belongs to
+        /// @returns the length of the range in UTF-8 codepoints, treating all line-break sequences
+        /// as a single code-point.
+        /// @see https://www.w3.org/TR/WGSL/#blankspace-and-line-breaks for the definition of a line
+        /// break.
+        size_t Length(const FileContent& content) const;
+
+        /// The location of the first UTF-8 codepoint in the range.
         Location begin;
-        /// The location of one-past the last character in the range.
+        /// The location of one-past the last UTF-8 codepoint in the range.
         Location end;
     };
 
diff --git a/src/tint/utils/diagnostic/source_test.cc b/src/tint/utils/diagnostic/source_test.cc
index cb50053..42b4e01 100644
--- a/src/tint/utils/diagnostic/source_test.cc
+++ b/src/tint/utils/diagnostic/source_test.cc
@@ -28,6 +28,7 @@
 #include "src/tint/utils/diagnostic/source.h"
 
 #include <memory>
+#include <string_view>
 #include <utility>
 
 #include "gtest/gtest.h"
@@ -35,7 +36,7 @@
 namespace tint {
 namespace {
 
-static constexpr const char* kSource = R"(line one
+static constexpr std::string_view kSource = R"(line one
 line two
 line three)";
 
@@ -81,7 +82,7 @@
 #define kLS "\xE2\x80\xA8"
 #define kPS "\xE2\x80\xA9"
 
-using LineBreakTest = testing::TestWithParam<const char*>;
+using LineBreakTest = testing::TestWithParam<std::string_view>;
 TEST_P(LineBreakTest, Single) {
     std::string src = "line one";
     src += GetParam();
@@ -108,5 +109,50 @@
                          LineBreakTest,
                          testing::Values(kVTab, kFF, kNL, kLS, kPS, kLF, kCR, kCR kLF));
 
+using RangeLengthTest = testing::TestWithParam<std::pair<Source::Range, size_t>>;
+TEST_P(RangeLengthTest, Test) {
+    Source::FileContent fc("X" kLF       // 1
+                           "XX" kCR kLF  // 2
+                           "X" kCR       // 3
+                               kLS       // 4
+                           "XX"          // 5
+    );
+    auto& range = GetParam().first;
+    auto expected_length = GetParam().second;
+    EXPECT_EQ(range.Length(fc), expected_length);
+}
+
+INSTANTIATE_TEST_SUITE_P(SingleLine,
+                         RangeLengthTest,
+                         testing::Values(  //
+
+                             std::make_pair(Source::Range{{1, 1}, {1, 1}}, 0),
+                             std::make_pair(Source::Range{{2, 1}, {2, 1}}, 0),
+                             std::make_pair(Source::Range{{3, 1}, {3, 1}}, 0),
+                             std::make_pair(Source::Range{{4, 1}, {4, 1}}, 0),
+                             std::make_pair(Source::Range{{5, 1}, {5, 1}}, 0),
+
+                             std::make_pair(Source::Range{{1, 1}, {1, 2}}, 1),
+                             std::make_pair(Source::Range{{2, 1}, {2, 3}}, 2),
+                             std::make_pair(Source::Range{{3, 1}, {3, 2}}, 1),
+                             std::make_pair(Source::Range{{5, 1}, {5, 3}}, 2),
+
+                             std::make_pair(Source::Range{{1, 2}, {1, 2}}, 0),
+                             std::make_pair(Source::Range{{2, 2}, {2, 3}}, 1),
+                             std::make_pair(Source::Range{{3, 2}, {3, 2}}, 0),
+                             std::make_pair(Source::Range{{5, 2}, {5, 3}}, 1)));
+
+INSTANTIATE_TEST_SUITE_P(MultiLine,
+                         RangeLengthTest,
+                         testing::Values(  //
+
+                             std::make_pair(Source::Range{{1, 1}, {2, 1}}, 2),
+                             std::make_pair(Source::Range{{2, 1}, {3, 1}}, 3),
+                             std::make_pair(Source::Range{{3, 1}, {4, 1}}, 2),
+                             std::make_pair(Source::Range{{4, 1}, {5, 1}}, 1),
+
+                             std::make_pair(Source::Range{{1, 1}, {5, 3}}, 10),
+                             std::make_pair(Source::Range{{2, 2}, {5, 2}}, 6)));
+
 }  // namespace
 }  // namespace tint