protostar 0.1.0.beta1

data/lib/protostar/lint/rules/rpc_response_standard_name.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # RPC_RESPONSE_STANDARD_NAME: An rpc whose response is not `<Rpc>Response`
+      class RpcResponseStandardName < Rule
+        REASON = "A response message of its own per RPC can grow fields without touching any other RPC."
+        EXPLANATION = <<~TEXT
+          Returning a shared type such as `User` means a field added for one RPC shows up in all of them.
+
+              rpc GetUser(GetUserRequest) returns (User);
+
+          Fix: `returns (GetUserResponse)`, with a `User user = 1;` field in it.
+        TEXT
+
+        def check
+          context.each(:service) do |service_node, service|
+            service.rpcs.each_with_index do |rpc, i|
+              base = Naming.pascal(rpc.name)
+              wanted = ["#{base}Response", "#{service.name}#{base}Response"]
+              next if wanted.include?(rpc.output_type.name)
+              report(service_node.rpcs[i], :output_type, "response of `#{rpc.name}` is `#{rpc.output_type.name}`, not `#{wanted[0]}`",
+                label: "not `#{wanted[0]}`", help: "return a `#{wanted[0]}` message of its own")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/service_pascal_case.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # SERVICE_PASCAL_CASE: A service name that is not PascalCase
+      class ServicePascalCase < Rule
+        REASON = "Services become classes and interfaces in generated code; PascalCase is what generators expect."
+        EXPLANATION = <<~TEXT
+              service user_api {}
+
+          Fix: `service UserAPIService {}`.
+        TEXT
+
+        def check
+          context.each(:service) do |node, service|
+            next if Naming.pascal?(service.name)
+            report(node, :name, "service `#{service.name}` is not PascalCase", label: "not PascalCase",
+              help: "name it `#{Naming.pascal(service.name)}`")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/service_suffix.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # SERVICE_SUFFIX: A service whose name does not end in `Service`
+      class ServiceSuffix < Rule
+        REASON = "A `Service` suffix keeps the generated client and server names from colliding with message names."
+        EXPLANATION = <<~TEXT
+          Generators name stubs and base classes after the service; `service User` next to `message User` makes
+          those collide or read ambiguously.
+
+              service Users { rpc Get(GetRequest) returns (GetResponse); }
+
+          Fix: `service UsersService`.
+        TEXT
+
+        def check
+          context.each(:service) do |node, service|
+            next if service.name.end_with?("Service")
+            report(node, :name, "service `#{service.name}` does not end in `Service`", label: "no `Service` suffix",
+              help: "name it `#{service.name}Service`")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/syntax_specified.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # SYNTAX_SPECIFIED: A file without a `syntax` or `edition` line
+      class SyntaxSpecified < Rule
+        REASON = "Without `syntax` or `edition` a file is proto2, which is rarely what its author meant."
+        EXPLANATION = <<~TEXT
+          protoc reads a file with neither line as proto2, silently. Fields then need labels, enums are closed, and
+          defaults behave differently from proto3; a reader of the file cannot tell which was intended.
+
+              message User {
+                optional string name = 1;
+              }
+
+          Fix: start the file with `edition = "2023";` (or `syntax = "proto3";`). `--fix` adds
+          `syntax = "proto2";`, which spells out what the file already is.
+        TEXT
+
+        def check
+          return if context.ast.syntax || context.ast.edition
+          text = context.text
+          fix = unless text.start_with?("\xEF\xBB\xBF".b) || text.b.start_with?("\xEF\xBB\xBF".b)
+            Diagnostics::Fix.new("add `syntax = \"proto2\";`, which is what the file already is",
+              [Diagnostics::Edit.new(1, 1, 1, 1, "syntax = \"proto2\";\n")])
+          end
+          span = Diagnostics::Span.new(1, 1, label: "proto2 by default")
+          add("file `#{context.name}` has no `syntax` or `edition` line", [span],
+            help: "start the file with `edition = \"2023\";` or `syntax = \"proto3\";`", fix: fix)
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/runner.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    # Compiles each file on its own, so one that fails does not stop the
+    # others, sharing one pool so imports are built once; then runs the rules
+    # over every file that compiled.
+    #
+    # The compiler's diagnostics come first, in the order it reports them
+    # (protoc's): errors from any file, warnings for the files asked about.
+    # Then each file's lint findings, in file order and by position within a
+    # file. Comment directives switch off warnings, never errors.
+    class Runner
+      # What a run found
+      class Result
+        # @return [Array<Compiler::Diagnostic>]
+        attr_reader :diagnostics
+        # @return [Array<Context>] the files that compiled
+        attr_reader :contexts
+        # @return [Array<String>] every file asked about
+        attr_reader :names
+
+        def initialize(diagnostics, contexts, names)
+          @diagnostics = diagnostics.freeze
+          @contexts = contexts.freeze
+          @names = names.freeze
+          freeze
+        end
+
+        def errors?
+          @diagnostics.any?(&:error?)
+        end
+
+        def warnings?
+          @diagnostics.any?(&:warning?)
+        end
+      end
+
+      # @return [Compiler]
+      attr_reader :compiler
+
+      # @param include_paths [Array<String>] where file names and imports are resolved
+      # @param rules [Array<String>] rule ids to run, from {Lint.select}
+      # @param except [Array<String>] rule ids switched off by name; the compiler
+      #   warnings they would report are not passed through either
+      # @param directives [Boolean] honour `// protostar-lint:` comments
+      def initialize(include_paths:, rules:, except: [], directives: true)
+        @compiler = Compiler.new(include_paths: include_paths)
+        @rules = rules.map { |id| Lint.rule_class(id) }
+        @claimed = (rules + except).flat_map { |id| Lint.rule_class(id)::CLAIMS }.uniq
+        @directives = directives
+        @texts = {}
+      end
+
+      # @param names [Array<String>] file names relative to an include path
+      # @param sources [Hash{String => String}] file contents by name, before the include paths
+      # @return [Result]
+      def run(names, sources: {})
+        @sources = sources
+        reported = []
+        seen = {}
+        linkers = {}
+        names.each do |name|
+          run = Compiler::Run.new(@compiler, [name], true, sources: sources, all_direct: true)
+          if linkers[name]
+            # built as an import of an earlier file: only the checks protoc
+            # runs on the files it is given are left
+            Compiler::Validator.cli_checks([linkers[name]], run)
+          else
+            run.call
+          end
+          run.diagnostics.each do |d|
+            next if seen[d]
+            seen[d] = true
+            reported << d
+          end
+          names.each { |n| linkers[n] ||= run.linker(n) }
+        end
+        failed = reported.select(&:error?).map(&:file).uniq
+        contexts = []
+        names.each do |name|
+          next if linkers[name].nil? || failed.include?(name)
+          warnings = reported.select { |d| d.warning? && d.file == name }
+          contexts << Context.new(name: name, path: shown_path(name), disk_path: disk_path(name),
+            linker: linkers[name], text: text(name), warnings: warnings, all: contexts)
+        end
+        diagnostics = reported.select do |d|
+          d.error? || (names.include?(d.file) && !@claimed.include?(d.code) && !suppressed?(d))
+        end
+        contexts.each { |context| diagnostics.concat(lint(context)) }
+        Result.new(diagnostics, contexts, names)
+      end
+
+      # @param name [String]
+      # @return [String, nil] the file's text, from the sources given or from disk
+      def text(name)
+        return @texts[name] if @texts.key?(name)
+        @texts[name] = if @sources&.key?(name)
+          @sources[name]
+        elsif (path = @compiler.resolve(name))
+          ::File.binread(path)
+        end
+      end
+
+      private
+
+      def lint(context)
+        found = @rules.flat_map do |rule_class|
+          rule = rule_class.new(context)
+          rule.check
+          rule.diagnostics
+        end
+        found.reject! { |d| suppressed?(d) }
+        found.each_with_index.sort_by { |d, i| [d.line || 0, d.column || 0, i] }.map(&:first)
+      end
+
+      def suppressed?(diagnostic)
+        return false unless @directives && diagnostic.warning?
+        @parsed ||= {}
+        directives = @parsed[diagnostic.file] ||= (text = text(diagnostic.file)) && Directives.new(text)
+        directives ? directives.suppressed?(diagnostic) : false
+      end
+
+      def shown_path(name)
+        return nil if @sources.key?(name)
+        @compiler.disk_path(name)
+      end
+
+      def disk_path(name)
+        return nil if @sources.key?(name)
+        @compiler.resolve(name)
+      end
+    end
+  end
+end

data/lib/protostar/lint.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Protostar
+  # `protostar lint`: compiles `.proto` files, reports the compiler's errors
+  # with {Diagnostics::Renderer}, and checks the files that compiled against
+  # best-practice rules, the kind `buf lint` checks, under the same names.
+  #
+  #   runner = Protostar::Lint::Runner.new(include_paths: ["proto"], rules: Protostar::Lint.select(["default"]))
+  #   result = runner.run(["acme/person.proto"])
+  #   result.diagnostics.each { |d| puts d }
+  #
+  # Each rule is one class under {Lint::Rules}, in a file named after its id,
+  # and one line in {RULES}.
+  module Lint
+    autoload :Rule, ::File.expand_path("lint/rule", __dir__)
+    autoload :Context, ::File.expand_path("lint/context", __dir__)
+    autoload :Naming, ::File.expand_path("lint/naming", __dir__)
+    autoload :Config, ::File.expand_path("lint/config", __dir__)
+    autoload :Directives, ::File.expand_path("lint/directives", __dir__)
+    autoload :Runner, ::File.expand_path("lint/runner", __dir__)
+    autoload :Fixer, ::File.expand_path("lint/fixer", __dir__)
+    autoload :Command, ::File.expand_path("lint/command", __dir__)
+
+    # Raised for a configuration or command-line mistake
+    class Error < Protostar::Error; end
+
+    # The sets a rule can be in, each including the one before
+    TIERS = %i[minimal default strict].freeze
+
+    # Every rule: id => [code, the smallest set it is in, its category]
+    RULES = {
+      "FIELD_NOT_REQUIRED" => ["W0101", :minimal, :longevity],
+      "NO_GROUPS" => ["W0102", :minimal, :longevity],
+      "ENUM_ZERO_VALUE_SUFFIX" => ["W0103", :minimal, :longevity],
+      "ENUM_FIRST_VALUE_ZERO" => ["W0104", :minimal, :longevity],
+      "FIELD_NUMBER_REUSE_RISK" => ["W0105", :minimal, :longevity],
+      "RESERVED_NAMES_WITH_NUMBERS" => ["W0106", :minimal, :longevity],
+      "PACKAGE_DEFINED" => ["W0107", :minimal, :longevity],
+      "IMPORT_NO_PUBLIC" => ["W0108", :minimal, :longevity],
+      "IMPORT_NO_WEAK" => ["W0109", :minimal, :longevity],
+      "IMPORT_USED" => ["W0110", :minimal, :longevity],
+      "SYNTAX_SPECIFIED" => ["W0111", :minimal, :longevity],
+      "FILE_LOWER_SNAKE_CASE" => ["W0201", :default, :naming],
+      "PACKAGE_LOWER_SNAKE_CASE" => ["W0202", :default, :naming],
+      "MESSAGE_PASCAL_CASE" => ["W0203", :default, :naming],
+      "FIELD_LOWER_SNAKE_CASE" => ["W0204", :default, :naming],
+      "ONEOF_LOWER_SNAKE_CASE" => ["W0205", :default, :naming],
+      "ENUM_PASCAL_CASE" => ["W0206", :default, :naming],
+      # before UPPER_SNAKE_CASE: when both rename a value, the prefixed name fixes both
+      "ENUM_VALUE_PREFIX" => ["W0208", :default, :naming],
+      "ENUM_VALUE_UPPER_SNAKE_CASE" => ["W0207", :default, :naming],
+      "SERVICE_PASCAL_CASE" => ["W0209", :default, :naming],
+      "SERVICE_SUFFIX" => ["W0210", :default, :naming],
+      "RPC_PASCAL_CASE" => ["W0211", :default, :naming],
+      "RPC_REQUEST_STANDARD_NAME" => ["W0212", :default, :naming],
+      "RPC_RESPONSE_STANDARD_NAME" => ["W0213", :default, :naming],
+      "RPC_REQUEST_RESPONSE_UNIQUE" => ["W0214", :default, :naming],
+      "PACKAGE_DIRECTORY_MATCH" => ["W0301", :default, :structure],
+      "PACKAGE_SAME_DIRECTORY" => ["W0302", :default, :structure],
+      "NO_DEPRECATED_FEATURES" => ["W0303", :default, :structure],
+      "PACKAGE_VERSION_SUFFIX" => ["W0304", :strict, :structure],
+      "FIELD_NUMBERS_HOT_RANGE" => ["W0305", :strict, :structure],
+      "COMMENT_MESSAGE" => ["W0401", :strict, :documentation],
+      "COMMENT_FIELD" => ["W0402", :strict, :documentation],
+      "COMMENT_ENUM" => ["W0403", :strict, :documentation],
+      "COMMENT_ENUM_VALUE" => ["W0404", :strict, :documentation],
+      "COMMENT_SERVICE" => ["W0405", :strict, :documentation],
+      "COMMENT_RPC" => ["W0406", :strict, :documentation],
+      "EDITION_RECOMMENDED" => ["W0501", :strict, :editions]
+    }.freeze
+
+    # The rule classes, each loading its file on first use
+    module Rules
+      RULES.each_key do |id|
+        autoload(id.split("_").map(&:capitalize).join.to_sym, ::File.expand_path("lint/rules/#{id.downcase}", __dir__))
+      end
+    end
+
+    # @return [Array<Symbol>] the category names a rule list can use
+    def self.categories
+      RULES.values.map(&:last).uniq
+    end
+
+    # @param id [String] a rule id
+    # @return [Class] its {Rule} subclass
+    def self.rule_class(id)
+      Rules.const_get(id.split("_").map(&:capitalize).join, false)
+    end
+
+    # @param id_or_code [String] "FIELD_NOT_REQUIRED" or "W0101"
+    # @return [String, nil] the rule id
+    def self.rule_id(id_or_code)
+      key = id_or_code.upcase
+      return key if RULES.key?(key)
+      RULES.find { |_, (code, _, _)| code == key }&.first
+    end
+
+    # The rules a list of set names, category names and rule ids selects, in
+    # {RULES} order
+    # @param names [Array<String>] e.g. ["default", "documentation", "PACKAGE_VERSION_SUFFIX"]
+    # @param except [Array<String>] rule ids or codes to leave out
+    # @return [Array<String>] rule ids
+    # @raise [Error] for a name that is none of these
+    def self.select(names, except: [])
+      chosen = names.flat_map do |name|
+        key = name.to_s.strip
+        if TIERS.include?(key.downcase.to_sym)
+          upto = TIERS.index(key.downcase.to_sym)
+          RULES.select { |_, (_, tier, _)| TIERS.index(tier) <= upto }.keys
+        elsif categories.include?(key.downcase.to_sym)
+          RULES.select { |_, (_, _, category)| category == key.downcase.to_sym }.keys
+        elsif (id = rule_id(key))
+          [id]
+        else
+          raise Error, "Unknown rule or set: #{key} (sets: #{TIERS.join(", ")}; categories: #{categories.join(", ")})"
+        end
+      end
+      skipped = except.map { |name| rule_id(name.to_s.strip) || raise(Error, "Unknown rule: #{name}") }
+      RULES.keys & (chosen - skipped)
+    end
+  end
+end

data/lib/protostar/message/accessors.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Protostar
+  class Message
+    # Writes the field accessors of a message class as Ruby source and evals
+    # it into the class. Methods made from source, unlike `define_method`
+    # blocks, can be called from any Ractor, and they read their slot by a
+    # literal index.
+    # @api private
+    module Accessors
+      module_function
+
+      # Methods every message has; a field whose accessor would replace one
+      # is reachable only through `[]` and `[]=`
+      def reserved
+        (Message.public_instance_methods + %i[initialize]).to_h { |m| [m, true] }
+      end
+
+      # @param klass [Class]
+      # @param fields [Array<FieldInfo>]
+      # @param oneofs [Array<Array(Symbol, Array<Integer>)>] real oneofs: name and member slots
+      # @param reserved [Hash{Symbol => true}] from {reserved}, computed once for many classes
+      def install(klass, fields, oneofs, reserved = self.reserved)
+        taken = reserved.dup
+        src = +""
+        fields.each do |info|
+          name = info.name
+          i = info.index
+          reader = name.to_sym
+          writer = :"#{name}="
+          unless taken[reader]
+            taken[reader] = true
+            src << reader_source(name, info)
+          end
+          unless taken[writer]
+            taken[writer] = true
+            src << "def #{name}=(v); __set(#{i}, v); end\n"
+          end
+          next unless info.presence
+          has = :"has_#{name}?"
+          clear = :"clear_#{name}"
+          unless taken[has]
+            taken[has] = true
+            src << "def has_#{name}?; !@values[#{i}].nil?; end\n"
+          end
+          unless taken[clear]
+            taken[clear] = true
+            src << "def clear_#{name}; __clear(#{i}); end\n"
+          end
+        end
+        oneofs.each do |oneof_name, slots|
+          which = :"which_#{oneof_name}"
+          next if taken[which]
+          taken[which] = true
+          src << "def which_#{oneof_name}\n"
+          slots.each do |slot|
+            src << "  return :#{fields[slot].name} unless @values[#{slot}].nil?\n"
+          end
+          src << "  nil\nend\n"
+        end
+        klass.class_eval(src, "(protostar #{klass.descriptor.full_name})", 1)
+      end
+
+      def reader_source(name, info)
+        i = info.index
+        if info.repeated || info.map
+          "def #{name}; @values[#{i}] || __container(#{i}); end\n"
+        elsif info.message? || !info.presence
+          "def #{name}; @values[#{i}]; end\n"
+        else
+          "def #{name}; v = @values[#{i}]; v.nil? ? #{default_literal(info)} : v; end\n"
+        end
+      end
+
+      # The default as a literal when it has an exact one, otherwise a lookup
+      def default_literal(info)
+        d = info.default
+        case d
+        when Integer, true, false, Symbol then d.inspect
+        when Float then d.finite? ? d.inspect : "self.class.__fields[#{info.index}].default"
+        else "self.class.__fields[#{info.index}].default"
+        end
+      end
+    end
+  end
+end

data/lib/protostar/message/coercion.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Protostar
+  class Message
+    # Checks and converts values assigned to fields. Everything stored in a
+    # message has been through here (or through the decoder, which produces
+    # the same shapes): Integers in range, Floats, true/false, frozen UTF-8 or
+    # binary Strings, enum Symbols (or Integers for numbers without a name),
+    # messages of the field's class.
+    # @api private
+    module Coercion
+      RANGES = {
+        FieldInfo::INT32 => -0x8000_0000..0x7FFF_FFFF,
+        FieldInfo::SINT32 => -0x8000_0000..0x7FFF_FFFF,
+        FieldInfo::SFIXED32 => -0x8000_0000..0x7FFF_FFFF,
+        FieldInfo::UINT32 => 0..0xFFFF_FFFF,
+        FieldInfo::FIXED32 => 0..0xFFFF_FFFF,
+        FieldInfo::INT64 => -0x8000_0000_0000_0000..0x7FFF_FFFF_FFFF_FFFF,
+        FieldInfo::SINT64 => -0x8000_0000_0000_0000..0x7FFF_FFFF_FFFF_FFFF,
+        FieldInfo::SFIXED64 => -0x8000_0000_0000_0000..0x7FFF_FFFF_FFFF_FFFF,
+        FieldInfo::UINT64 => 0..0xFFFF_FFFF_FFFF_FFFF,
+        FieldInfo::FIXED64 => 0..0xFFFF_FFFF_FFFF_FFFF
+      }.freeze
+
+      ENUM_RANGE = RANGES.fetch(FieldInfo::INT32)
+      FLOAT_MAX = 3.4028234663852886e+38
+      # Halfway between FLT_MAX and 2**128: doubles below it round to FLT_MAX
+      FLOAT_ROUNDS_TO_MAX = 3.4028235677973366e+38
+      UTF_8 = Encoding::UTF_8
+      BINARY = Encoding::BINARY
+
+      module_function
+
+      # @param info [FieldInfo]
+      # @return [Object] what gets stored for a non-nil value assigned to the field
+      # @raise [Protostar::TypeError]
+      def field(info, value)
+        if info.map
+          raise_type(info, value, "a Hash") unless value.is_a?(Hash)
+          key = info.key
+          val = info.value
+          out = {}
+          value.each { |k, v| out[scalar(key, k)] = single(val, v) }
+          out
+        elsif info.repeated
+          raise_type(info, value, "an Array") unless value.is_a?(Array)
+          value.map { |v| single(info, v) }
+        else
+          single(info, value)
+        end
+      end
+
+      # One value of a singular field, an element of a repeated field, or a map value
+      def single(info, value)
+        if info.message?
+          klass = info.message_class
+          return value if value.instance_of?(klass)
+          return klass.new(value) if value.is_a?(Hash)
+          begin
+            coerced = klass.__coerce(value)
+          rescue RangeError
+            raise_type(info, value, "a finite value in #{klass.descriptor.full_name}'s range")
+          end
+          return coerced if coerced
+          raise_type(info, value, "a #{klass.descriptor.full_name} or a Hash")
+        end
+        scalar(info, value)
+      end
+
+      def scalar(info, value)
+        case (kind = info.kind)
+        when FieldInfo::DOUBLE
+          raise_type(info, value, "a Numeric") unless value.is_a?(Float) || value.is_a?(Integer)
+          value.to_f
+        when FieldInfo::FLOAT
+          raise_type(info, value, "a Numeric") unless value.is_a?(Float) || value.is_a?(Integer)
+          # stored at single precision so that reads match what decoding gives back
+          float32(value.to_f)
+        when FieldInfo::BOOL
+          raise_type(info, value, "true or false") unless value == true || value == false
+          value
+        when FieldInfo::STRING
+          string(info, value)
+        when FieldInfo::BYTES
+          raise_type(info, value, "a String") unless value.is_a?(String)
+          (value.frozen? && value.encoding == BINARY) ? value : value.b.freeze
+        when FieldInfo::ENUM
+          enum(info, value)
+        else
+          range = RANGES.fetch(kind)
+          unless value.is_a?(Integer) && range.cover?(value)
+            raise_type(info, value, "an Integer in #{info.descriptor.type} range")
+          end
+          value
+        end
+      end
+
+      # The nearest single-precision value, as C's double-to-float conversion
+      # gives it. `pack("e")` alone turns everything above FLT_MAX into
+      # Infinity, even values that round down to FLT_MAX, and every NaN into
+      # the same one.
+      def float32(f)
+        a = f.abs
+        if a > FLOAT_MAX && a < FLOAT_ROUNDS_TO_MAX
+          (f > 0) ? FLOAT_MAX : -FLOAT_MAX
+        elsif f.nan?
+          Wire.float_nan(f).unpack1("e")
+        else
+          [f].pack("e").unpack1("e")
+        end
+      end
+
+      def string(info, value)
+        raise_type(info, value, "a String") unless value.is_a?(String)
+        enc = value.encoding
+        if enc == UTF_8
+          raise_type(info, value, "valid UTF-8") unless value.valid_encoding?
+          value.frozen? ? value : value.dup.freeze
+        elsif enc == BINARY || enc == Encoding::US_ASCII
+          s = value.dup.force_encoding(UTF_8)
+          raise_type(info, value, "valid UTF-8") unless s.valid_encoding?
+          s.freeze
+        else
+          begin
+            value.encode(UTF_8).freeze
+          rescue EncodingError
+            raise_type(info, value, "a String convertible to UTF-8")
+          end
+        end
+      end
+
+      def enum(info, value)
+        if value.is_a?(Symbol)
+          number = info.enum_numbers[value]
+          raise_type(info, value, "a value of #{info.enum_module.descriptor.full_name}") unless number
+          info.enum_names.fetch(number)
+        elsif value.is_a?(Integer)
+          name = info.enum_names[value]
+          return name if name
+          if info.closed_enum || !ENUM_RANGE.cover?(value)
+            raise_type(info, value, "a value of #{info.enum_module.descriptor.full_name}")
+          end
+          value
+        else
+          raise_type(info, value, "a Symbol or Integer")
+        end
+      end
+
+      # Whether a value found in a repeated field or map is one the encoder can
+      # write. Those containers are plain Arrays and Hashes that callers may
+      # have filled directly, past the writers' checks.
+      def storable?(info, value)
+        case (kind = info.kind)
+        when FieldInfo::DOUBLE, FieldInfo::FLOAT then value.is_a?(Float) || value.is_a?(Integer)
+        when FieldInfo::BOOL then value == true || value == false
+        when FieldInfo::STRING, FieldInfo::BYTES then value.is_a?(String)
+        when FieldInfo::ENUM
+          value.is_a?(Symbol) ? info.enum_numbers.key?(value) : (value.is_a?(Integer) && ENUM_RANGE.cover?(value))
+        when FieldInfo::MESSAGE, FieldInfo::GROUP then value.instance_of?(info.message_class)
+        else value.is_a?(Integer) && RANGES.fetch(kind).cover?(value)
+        end
+      end
+
+      def raise_type(info, value, expected)
+        shown = value.inspect
+        shown = "#{shown[0, 60]}..." if shown.length > 64
+        raise Protostar::TypeError, "#{info.descriptor.full_name} expects #{expected}, got #{shown}"
+      end
+    end
+  end
+end