Redo "Work-around for missing mixin-application charOffset"

pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fasta.kernel_library_builder;
 
 import 'package:front_end/src/fasta/dill/dill_library_builder.dart';
 import 'package:front_end/src/fasta/combinator.dart' as fasta;
 import 'package:front_end/src/fasta/export.dart';
 import 'package:front_end/src/fasta/import.dart';
@@ skipping 272 matching lines @@
       List<KernelTypeBuilder> interfaces,
       int charOffset: -1}) {
     if (type is KernelMixinApplicationBuilder) {
       subclassName ??= name;
       List<List<String>> signatureParts = <List<String>>[];
       Map<String, String> unresolved = <String, String>{};
       Map<String, String> unresolvedReversed = <String, String>{};
       int unresolvedCount = 0;
       Map<String, TypeBuilder> freeTypes = <String, TypeBuilder>{};
 
+      // TODO(30316): Use correct locations of mixin applications
+      // (e.g. identifiers for mixed-in classes).
+      if (charOffset == -1) charOffset = type.charOffset;
+
       if (name == null || type.mixins.length != 1) {
         TypeBuilder last = type.mixins.last;
 
         /// Compute a signature of the type arguments used by the supertype and
         /// mixins. These types are free variables. At this point we can't
         /// trust that the number of type arguments match the type parameters,
         /// so we also need to be able to detect missing type arguments.  To do
         /// so, we separate each list of type arguments by `^` and type
         /// arguments by `&`. For example, the mixin `C<S> with M<T, U>` would
         /// look like this:
@@ skipping 109 matching lines @@
               -1);
         }
         KernelNamedTypeBuilder mixin = type.mixins[i];
         for (var type in mixin.arguments ?? const []) {
           type.bind(variables[type.name]);
         }
         checkArguments(supertype);
         checkArguments(mixin);
         supertype = applyMixin(supertype, mixin, signature,
             isSyntheticMixinImplementation: true,
-            typeVariables:
-                new List<TypeVariableBuilder>.from(variables.values));
+            typeVariables: new List<TypeVariableBuilder>.from(variables.values),
+            charOffset: charOffset);
       }
       KernelNamedTypeBuilder mixin = type.mixins.last;
 
       Set<String> supertypeArguments = new Set<String>();
       for (var part in currentSignatureParts) {
         supertypeArguments.addAll(part);
       }
       String signature = name == null ? computeSignature() : "";
       var variables;
       if (name == null) {
@@ skipping 513 matching lines @@
           mixinApplicationClasses.putIfAbsent(name, () => builder);
       if (existing != builder) {
         part.scope.local.remove(name);
       }
     });
     super.includePart(part);
     nativeMethods.addAll(part.nativeMethods);
     boundlessTypeVariables.addAll(part.boundlessTypeVariables);
   }
 }