Rename mixin protos and add a check for undefined mixin name

lib/file_generator.dart

 // Copyright (c) 2013, 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.
 
 part of protoc;
 
 final _dartIdentifier = new RegExp(r'^\w+$');
 
 /// Generates the Dart output files for one .proto input file.
 ///
 /// Outputs include .pb.dart, pbenum.dart, and .pbjson.dart.
 class FileGenerator extends ProtobufContainer {
   /// Reads and the declared mixins in the file, keyed by name.
   ///
   /// Performs some basic validation on declared mixins, e.g. whether names
   /// are valid dart identifiers and whether there are cycles in the `parent`
   /// hierarchy.
   /// Does not check for existence of import files or classes.
   static Map<String, PbMixin> _getDeclaredMixins(FileDescriptorProto desc) {
     String mixinError(String error) =>
-        'Option "mixins" in file ${desc.name}: $error';
+        'Option "mixins" in ${desc.name}: $error';
 
     if (!desc.hasOptions() ||
-        !desc.options.hasExtension(Dart_options.importedMixins)) {
+        !desc.options.hasExtension(Dart_options.imports)) {
       return <String, PbMixin>{};
     }
     var dartMixins = <String, DartMixin>{};
-    ImportedMixins importedMixins =
-        desc.options.getExtension(Dart_options.importedMixins);
+    Imports importedMixins = desc.options.getExtension(Dart_options.imports);

[frederikmutzel, 2016/06/28 08:15:13]

maybe rename the variable to imports as well?

[skybrian, 2016/06/28 08:40:34]

Skipping for now.

     for (DartMixin mixin in importedMixins.mixins) {
       if (dartMixins.containsKey(mixin.name)) {
         throw mixinError('Duplicate mixin name: "${mixin.name}"');
       }
       if (!mixin.name.startsWith(_dartIdentifier)) {
         throw mixinError(
             '"${mixin.name}" is not a valid dart class identifier');
       }
       if (mixin.hasParent() && !mixin.parent.startsWith(_dartIdentifier)) {
         throw mixinError('Mixin parent "${mixin.parent}" of "${mixin.name}" is '
@@ skipping 42 matching lines @@
         return pbMixin;
       }
       return findMixin(name);
     }
     for (var mixin in dartMixins.values) {
       resolveMixin(mixin.name);
     }
     return pbMixins;
   }
 
-  final FileDescriptorProto _fileDescriptor;
+  final FileDescriptorProto descriptor;
 
   // The relative path used to import the .proto file, as a URI.
   final Uri protoFileUri;
 
   final List<EnumGenerator> enumGenerators = <EnumGenerator>[];
   final List<MessageGenerator> messageGenerators = <MessageGenerator>[];
   final List<ExtensionGenerator> extensionGenerators = <ExtensionGenerator>[];
   final List<ClientApiGenerator> clientApiGenerators = <ClientApiGenerator>[];
   final List<ServiceGenerator> serviceGenerators = <ServiceGenerator>[];
 
   /// True if cross-references have been resolved.
   bool _linked = false;
 
   FileGenerator(FileDescriptorProto descriptor)
-      : _fileDescriptor = descriptor,
+      : descriptor = descriptor,
         protoFileUri = new Uri.file(descriptor.name) {
     if (protoFileUri.isAbsolute) {
       // protoc should never generate an import with an absolute path.
       throw "FAILURE: Import with absolute path is not supported";
     }
 
     var declaredMixins = _getDeclaredMixins(descriptor);
     var defaultMixinName =
         descriptor.options?.getExtension(Dart_options.defaultMixin) ?? '';
     var defaultMixin =
         declaredMixins[defaultMixinName] ?? findMixin(defaultMixinName);
     if (defaultMixin == null && defaultMixinName.isNotEmpty) {
       throw ('Option default_mixin on file ${descriptor.name}: Unknown mixin '
           '$defaultMixinName');
     }
 
     // Load and register all enum and message types.
-    for (EnumDescriptorProto enumType in _fileDescriptor.enumType) {
+    for (EnumDescriptorProto enumType in descriptor.enumType) {
       enumGenerators.add(new EnumGenerator(enumType, this));
     }
-    for (DescriptorProto messageType in _fileDescriptor.messageType) {
+    for (DescriptorProto messageType in descriptor.messageType) {
       messageGenerators.add(new MessageGenerator(
           messageType, this, declaredMixins, defaultMixin));
     }
-    for (FieldDescriptorProto extension in _fileDescriptor.extension) {
+    for (FieldDescriptorProto extension in descriptor.extension) {
       extensionGenerators.add(new ExtensionGenerator(extension, this));
     }
-    for (ServiceDescriptorProto service in _fileDescriptor.service) {
+    for (ServiceDescriptorProto service in descriptor.service) {
       var serviceGen = new ServiceGenerator(service, this);
       serviceGenerators.add(serviceGen);
       clientApiGenerators.add(new ClientApiGenerator(serviceGen));
     }
   }
 
   /// Creates the fields in each message.
   /// Resolves field types and extension targets using the supplied context.
   void resolve(GenerationContext ctx) {
     if (_linked) throw new StateError("cross references already resolved");
 
     for (var m in messageGenerators) {
       m.resolve(ctx);
     }
     for (var x in extensionGenerators) {
       x.resolve(ctx);
     }
 
     _linked = true;
   }
 
-  String get package => _fileDescriptor.package;
+  String get package => descriptor.package;
   String get classname => '';
-  String get fqname => '.${_fileDescriptor.package}';
+  String get fqname => '.${descriptor.package}';
   FileGenerator get fileGen => this;
 
   // Extract the filename from a URI and remove the extension.
   String _fileNameWithoutExtension(Uri filePath) {
     String fileName = filePath.pathSegments.last;
     int index = fileName.lastIndexOf(".");
     return index == -1 ? fileName : fileName.substring(0, index);
   }
 
   String _generateClassName(Uri protoFilePath) {
     String s = _fileNameWithoutExtension(protoFilePath).replaceAll('-', '_');
     return '${s[0].toUpperCase()}${s.substring(1)}';
   }
 
   /// Generates all the Dart files for this .proto file.
   List<CodeGeneratorResponse_File> generateFiles(OutputConfiguration config) {
     if (!_linked) throw new StateError("not linked");
 
     makeFile(String extension, String content) {
-      Uri protoUrl = new Uri.file(_fileDescriptor.name);
+      Uri protoUrl = new Uri.file(descriptor.name);
       Uri dartUrl = config.outputPathFor(protoUrl, extension);
       return new CodeGeneratorResponse_File()
         ..name = dartUrl.path
         ..content = content;
     }
 
     return [
       makeFile(".pb.dart", generateMainFile(config)),
       makeFile(".pbenum.dart", generateEnumFile(config)),
       makeFile(".pbserver.dart", generateServerFile(config)),
@@ skipping 38 matching lines @@
     return out.toString();
   }
 
   /// Writes the header and imports for the .pb.dart file.
   void writeMainHeader(IndentingWriter out,
       [OutputConfiguration config = const DefaultOutputConfiguration()]) {
     _writeLibraryHeading(out);
 
     // We only add the dart:async import if there are services in the
     // FileDescriptorProto.
-    if (_fileDescriptor.service.isNotEmpty) {
+    if (descriptor.service.isNotEmpty) {
       out.println("import 'dart:async';\n");
     }
 
     if (_needsFixnumImport) {
       out.println("import 'package:fixnum/fixnum.dart';");
     }
 
     if (_needsProtobufImport) {
       out.println("import 'package:protobuf/protobuf.dart';");
       out.println();
@@ skipping 205 matching lines @@
       x.addConstantImportsTo(imports);
     }
     imports.remove(this); // Don't need to import self.
     return imports;
   }
 
   /// Writes the library name at the top of the dart file.
   ///
   /// (This should be unique to avoid warnings about duplicate Dart libraries.)
   void _writeLibraryHeading(IndentingWriter out, [String extension]) {
-    Uri filePath = new Uri.file(_fileDescriptor.name);
+    Uri filePath = new Uri.file(descriptor.name);
     if (filePath.isAbsolute) {
       // protoc should never generate a file descriptor with an absolute path.
       throw "FAILURE: File with an absolute path is not supported";
     }
 
     var libraryName = _fileNameWithoutExtension(filePath).replaceAll('-', '_');
     if (extension != null) libraryName += "_$extension";
-    if (_fileDescriptor.package != '') {
+    if (descriptor.package != '') {
       // Two .protos can be in the same proto package.
       // It isn't unique enough to use as a Dart library name.
       // But we can prepend it.
-      libraryName = _fileDescriptor.package + "_" + libraryName;
+      libraryName = descriptor.package + "_" + libraryName;
     }
     out.println('''
 ///
 //  Generated code. Do not modify.
 ///
 library $libraryName;
 ''');
   }
 
   /// Writes an import of a .dart file corresponding to a .proto file.
   /// (Possibly the same .proto file.)
   void _writeImport(IndentingWriter out, OutputConfiguration config,
       FileGenerator target, String extension) {
     Uri resolvedImport =
         config.resolveImport(target.protoFileUri, protoFileUri, extension);
     out.print("import '$resolvedImport'");
     if (package != target.package && target.package.isNotEmpty) {
       out.print(' as ${target.packageImportPrefix}');
     }
     out.println(';');
   }
 }