carbon-compiler 0.2.0

data/lib/carbon/compiler/metanostic.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/metanostic/defaults"
+require "carbon/compiler/metanostic/diagnostic"
+require "carbon/compiler/metanostic/list"
+require "carbon/compiler/metanostic/mode"
+require "carbon/compiler/metanostic/state"
+
+module Carbon
+  module Compiler
+    # A "Metanostic."  A "metanostic" has information about what a diagnostic
+    # could be about.  For example, a `Diagnostic/Unknown` diagnostic has
+    # metanostic information; the name itself, the default mode, and the
+    # allowed modes are a part of that metanostic information.  Diagnostics
+    # are generated from both metanostic information and environmental
+    # information.
+    class Metanostic
+      include Comparable
+      # The name of the metanostic.  This is used as a unique identifier for
+      # the metanostic.  This is a string, and is normally represented as a
+      # path of CamelCase names.  For example, a name might be
+      # `Diagnostic/Unknown`.
+      #
+      # @return [::String]
+      attr_reader :name
+      # The allowed modes of a metanostic or diagnostic.  This limits how a
+      # diagnostic can be categorized.  This is a bitfield of modes.  If a
+      # metanostic can be any mode, this is `Metanostic::Mode::ALL`; otherwise,
+      # it is a union of all of the allowed modes of a diagnostic.
+      #
+      # @see Metanostic::Mode
+      # @return [::Integer]
+      attr_reader :allowed
+      # The default mode of derived diagnostics.  This is and must be an
+      # allowed diagnostic.
+      #
+      # @see #allowed
+      # @see Metanostic::Mode
+      # @return [::Integer]
+      attr_reader :default
+      # The default message of derived diagnostics, if the diagnostic does not
+      # provide one.  This is used to provide a generic message.
+      #
+      # @return [::String]
+      attr_reader :message
+
+      # Initialize the diagnostic with the given data.
+      #
+      # @param data [::Hash{::Symbol,::String => ::Object}]
+      # @option data [::String] :name The name of the metanostic.
+      # @option data [::Integer] :allowed The allowed modes of derived
+      #   diagnostics.
+      # @option data [::Integer] :default The default mode of derived
+      #   diagnostics.
+      # @option data [::String] :message The default message of derived
+      #   diagnostics.
+      # @raise [::KeyError] If one of the option keys is not present.
+      def initialize(data)
+        @name        = data.fetch(:name) { data.fetch("name") }
+        @allowed     = data.fetch(:allowed) { data.fetch("allowed") }
+        self.default = data.fetch(:default) { data.fetch("default") }
+        @message     = data.fetch(:message) { data.fetch("message") }
+      end
+
+      # Compares this with another metanostic.  This should only be used for
+      # equality; it makes no sense otherwise.
+      #
+      # @param other [Metanostic] The metanostic to compare to.
+      # @return [::Numeric]
+      def <=>(other)
+        fail ArgumentError, "Expected Metanostic" unless other.is_a?(Metanostic)
+        to_a <=> other.to_a
+      end
+
+      # Returns a numeric representation of this class for use of hashing.
+      #
+      # @return [::Numeric]
+      def hash
+        to_a.hash
+      end
+
+      # Returns an array representation of this class.  This is frozen.
+      #
+      # @return [(::Class, ::String, ::Integer, ::Integer, ::String)]
+      def to_a
+        [self.class, @name, @allowed, @default, @message].freeze
+      end
+
+      # Pretty inspect.
+      #
+      # @return [::String]
+      def inspect
+        "#<#{self.class} #{@name}(#{Mode.to_s(@default)}) " \
+          "[#{Mode.to_s(@allowed)}]>"
+      end
+
+      # Sets the default mode of the metanostic to the given mode.  The
+      # metanostic must have the corresponding allowed mode bit set.
+      #
+      # @see Metanostic::Mode
+      # @raise [DiagnosticError] If the metanostic cannot have the given mode
+      #   as the default.
+      # @return [::Integer] The new mode.
+      def default=(mode)
+        unless can_be?(mode)
+          fail DiagnosticError, "#{mode} is not allowed as a default"
+        end
+        @default = mode
+      end
+
+      # Checks to see if the metanostic or any derived diagnostics can have the
+      # given mode.
+      #
+      # @see Metanostic::Mode
+      # @param mode [Integer] The mode.
+      # @return [Boolean]
+      def can_be?(mode)
+        Mode.singular?(mode) && Mode.is?(allowed, mode)
+      end
+    end
+  end
+end

data/lib/carbon/compiler/metanostic/defaults.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require "yaml"
+
+module Carbon
+  module Compiler
+    class Metanostic
+      # Deals with loading default of metanostics.  It mostly takes defaults
+      # from a defaults.yml file in the same directory as this file.
+      module Defaults
+        # Load a file and return the metanostics contained within the files.
+        #
+        # @param file [String] The file to load from.  The file must contain
+        #   a YAML-formatted list of diagnostics.
+        # @return [{String => Metanostic}]
+        def self.load_file(file)
+          data = YAML.load_file(file)
+          metanostics = {}
+          data["metanostics"].each do |name, metanostic|
+            meta = { name: name,
+                     default: Mode.from(metanostic["default"]),
+                     allowed: Mode.from(metanostic["allowed"]),
+                     message: metanostic["message"] }
+            metanostics[name] = Metanostic.new(meta)
+          end
+
+          metanostics
+        end
+
+        # Returns a frozen hash of all the default metanostics.  Since it is
+        # frozen, it is cached.
+        #
+        # @return [{String => Metanostic}]
+        def self.defaults
+          @_defaults ||=
+            load_file(::File.expand_path("../defaults.yml", __FILE__)).freeze
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/metanostic/defaults.yml

@@ -0,0 +1,138 @@
+metanostics:
+  Test/All:
+    allowed: [all]
+    default: warning
+  Test/Ignore:
+    allowed: [all]
+    default: ignore
+  Test/Info:
+    allowed: [all]
+    default: info
+  Test/Warning:
+    allowed: [all]
+    default: warning
+  Test/Error:
+    allowed: [all]
+    default: error
+  Test/Panic:
+    allowed: [all]
+    default: panic
+  System/Error:
+    allowed: [panic]
+    default: panic
+    message: >-
+      The compiler encountered an unrecoverable error and must exit
+    note: >-
+      Results from internal usage of an unknown diagnostic so far.
+  Trace/Location:
+    allowed: [all]
+    default: warning
+    message: previous location is here
+    note: >-
+      Used for tracing the location of something.
+  Diagnostic/Unknown:
+    allowed: [all]
+    default: error
+    message: unknown diagnostic used
+  Diagnostic/Mode/Invalid:
+    allowed: [all]
+    default: error
+    message: an invalid mode was given
+  Syntax/Token/Unknown:
+    allowed: [panic]
+    default: panic
+    message: unknown token %s
+  Syntax/Token/Unexpected:
+    allowed: [panic]
+    default: panic
+    message: unexpected %s, expected one of %s
+  Module/Definition/MultipleData:
+    allowed: [error, panic]
+    default: error
+    message: too many data definitions in file
+    note: >-
+      The compiler preceeds with error checking using the first data
+      definition in the file.  However, the compiler never preceeds to the
+      emitting stage.
+  Module/Definition/MultipleNames:
+    allowed: [error, panic]
+    default: error
+    message: too many module name definitions in file
+    note: >-
+      The compiler preceeds with error checking using the first name
+      definition in the file.  However, the compiler never preceeds to the
+      emitting stage.
+  Module/Definition/MismatchedName:
+    allowed: [all]
+    default: error
+    message: expected name %s, found name %s
+    note: >-
+      The default behavior is to use the name in the file.  If the mode
+      is anything under panic, the name in the file is set as the name of
+      the module.
+  Module/Name/Invalid:
+    allowed: [error, panic]
+    default: error
+    message: the module name had an invalid component
+    note: >-
+      This typically doesn't happen except in directives, where a directive
+      was expecting a "normal" module name instead of the directive's
+      "extended" module name.
+  Module/Name/InvalidExtended:
+    allowed: [error, panic]
+    default: error
+    message: the star component of a module name was in an invalid position
+    note: >-
+      This only happens in an extended module name for a directive.  The
+      star of a module name must be at the end.
+  Module/Name/IgnoredGenerics:
+    allowed: [all]
+    default: warning
+    message: the module name includes generic information that will be discarded
+  Module/Name/UnexpectedGeneric:
+    allowed: [error, panic]
+    default: error
+    message: the module name includes generic information that was not expected
+  Diagnostic/Unknown:
+    allowed: [all]
+    default: error
+    message: an unknown directive was used
+    note: >-
+      The default behavior is to ignore the directive.
+  Directive/Parameter/Invalid:
+    allowed: [error, panic]
+    default: error
+    message: an invalid parameter for a directive was used
+    note: >-
+      Due to technical restraints, this also includes parameters that don't
+      exist.
+  Directive/Parameter/Excessive:
+    allowed: [warning, error, panic]
+    default: warning
+    message: expected %s, got %s
+    note: >-
+      The default behavior is to ignore the excessive parameters.
+  Enum/Definition/Duplicate:
+    allowed: [error, panic]
+    default: error
+    message: one or more elements in the enum were duplicated
+  Enum/Definition/ConflictingTypes:
+    allowed: [error, panic]
+    default: error
+    message: one or more elements had differing types
+  Struct/Definition/Duplicate:
+    allowed: [error, panic]
+    default: error
+    message: duplicate name %s
+  Function/Duplicate:
+    allowed: [error, panic]
+    default: error
+    message: a function was duplicated
+  Expression/Type/Mismatch:
+    allowed: [ignore, warning, error, panic]
+    default: error
+    message: found type %s, expected type %s
+  Statement/Let/Redefine:
+    allowed: [ignore, warning, error, panic]
+    default: error
+    message: attempted to redefine local %s

data/lib/carbon/compiler/metanostic/diagnostic.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Metanostic
+      # A diagnostic.  This is an actual diagnostic, spawned off of a metanostic
+      # and an issue in compiling a file.  This contains information about the
+      # related metanostic, the location of the diagnostic, an associated
+      # message, and the mode the diagnostic is considered.
+      class Diagnostic
+        TEMPLATESTR = File.read(File.expand_path("../template.erb", __FILE__))
+          .gsub(/\r\n|\r|\n/, "\n")
+        TEMPLATE = ERB.new(TEMPLATESTR, nil, ">")
+
+        include Comparable
+        # The associated metanostic.  This contains information about
+        # information the name and the allowed modes of this diagnostic.
+        #
+        # @return [Metanostic]
+        attr_reader :metanostic
+        # The associated location.  If the location is not given, it defaults
+        # to {Location.default}.
+        #
+        # @return [Location]
+        attr_reader :location
+        # The message for the diagnostic.  If none is given, it defaults to the
+        # metanostic's message.
+        #
+        # @return [String]
+        attr_reader :message
+        # The mode for the diagnostic.  This changes how the diagnostic is
+        # treated.
+        #
+        # @return [Integer]
+        attr_reader :mode
+
+        # Initializes the diagnostic, and then freezes it.
+        #
+        # @param data [{Symbol => Object}] Origin date for the diagnostic.
+        # @option data [Metanostic] :meta The associated metanostic.
+        #   See {#metanostic}.
+        # @option data [Location] :location The location. See {#location}.
+        # @option data [Integer] :mode The mode.  See {#mode}.
+        # @option data [String?] :message The message.  See {#message}.
+        # @raise [KeyError] If one of the above options was not present.
+        def initialize(data)
+          @metanostic = data.fetch(:meta)
+          @location = data.fetch(:location)
+          @mode = data.fetch(:mode)
+          @list = data.fetch(:list)
+          @stack = data.fetch(:stack) { caller[3..8] }
+          @message = data[:message] || @metanostic.message
+          to_a
+          freeze
+        end
+
+        # Outputs this diagnostic to the given IO.  If the mode is
+        # {Mode::IGNORE}, and {Carbon.verbose} is less than `1`, then the
+        # diagnostic is not output.
+        #
+        # @param io [#<<]
+        # @return [void]
+        def output(io)
+          return if mode == Mode::IGNORE && Carbon.verbose < 1
+          io << TEMPLATE.result(binding) << "\n"
+        end
+
+        # Compares this instance with another instance.  It does so by comparing
+        # the array representations of both; therefore, this makes no sense
+        # other than equality.
+        #
+        # @param other [Diagnostic] The diagnostic to compare.
+        # @return [Numeric]
+        def <=>(other)
+          fail ArgumentError, "Expected Diagnostic" unless \
+            other.is_a?(Diagnostic)
+          to_a <=> other.to_a
+        end
+
+        # Returns a numeric representation of this class for use of hashing.
+        #
+        # @return [Numeric]
+        def hash
+          to_a.hash
+        end
+
+        # An array representation of this class.  This is frozen and cached.
+        #
+        # @return [(Class, Metanostic, Location, Integer, String)]
+        def to_a
+          @array ||= [self.class, @metanostic, @location, @mode,
+            @message].freeze
+        end
+
+      private
+
+        def distance
+          @location.column.end - @location.column.begin
+        end
+
+        def lines
+          (@location.line.begin - 1)..(@location.line.end - 1)
+        end
+
+        def file
+          @list.files[@location.file]
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/metanostic/list.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Metanostic
+      # A list of diagnostics.  This handles setting up the modes of
+      # new, emitted diagnostics, and reporting diagnostic types.
+      class List
+        include Enumerable
+        extend Forwardable
+        # The current state.  This contains information about what modes each
+        # diagnostic should inherit.
+        #
+        # @return [State]
+        attr_reader :state
+        # The default hash of metanostics.
+        #
+        # @see Defaults.defaults
+        # @return [{::Hash => Metanostic}]
+        attr_reader :defaults
+        # The project files for the metanostic list.  This is to provide context
+        # for diagnostic errors.
+        #
+        # @retrun [{::String => Project::File}]
+        attr_reader :files
+
+        THRESHOLDS = {
+          "warnings" => 100,
+          "errors" => 20
+        }.freeze
+
+        delegate [:each, :size, :count, :length, :clear] => :@list
+
+        # Initialize the list.
+        def initialize
+          @defaults = Metanostic::Defaults.defaults
+          @state = State.new
+          @list = Concurrent::Array.new
+          @files = Concurrent::Hash.new
+        end
+
+        # Returns a list of diagnostics that have the {Mode::PANIC} mode.
+        #
+        # @return [<Diagnostic>]
+        def panics
+          select { |d| d.metanostic.default == Mode::PANIC }
+        end
+
+        # Returns a list of diagnostics that have the {Mode::ERROR} mode.
+        #
+        # @return [<Diagnostic>]
+        def errors
+          select { |d| d.metanostic.default == Mode::ERROR }
+        end
+
+        # Returns a list of diagnostics that have the {Mode::WARNING} mode.
+        #
+        # @return [<Diagnostic>]
+        def warnings
+          select { |d| d.metanostic.default == Mode::WARNING }
+        end
+
+        # Emits a diagnostic to the list.  It sets up the data to pass to the
+        # diagnostic.  If the diagnostic cannot be found, it instead emits a
+        # `System/Error` diagnostic.
+        def emit(name, location = Location.default, format = [])
+          mode, metanostic = @state.fetch(name) do
+            return emit("System/Error", location, [name])
+          end
+
+          message = format.is_a?(::String) ? format :
+            sprintf(metanostic.message, *format)
+
+          stack = caller[2..7]
+          diagnostic = Diagnostic.new(meta: metanostic, location: location,
+            message: message, mode: mode, list: self, stack: stack)
+          @list << diagnostic
+          diagnostic.output($stderr)
+          diagnostic_check
+        end
+
+        alias_method :<<, :emit
+        alias_method :push, :emit
+
+        # Outputs all of the diagnostics in this list.  Does nothing if
+        # {Carbon.quiet?} is true.
+        #
+        # @see Diagnostic#output
+        # @param io [#<<] The IO device to output to.
+        # @return [void]
+        def output(io)
+          return if Carbon.quiet?
+          each { |i| i.output(io, @files) }
+        end
+
+      private
+
+        def diagnostic_check
+          fail DiagnosticError, "Exceeded warning threshold" if \
+            warnings.size >= THRESHOLDS.fetch("warnings")
+          fail DiagnosticError, "Exceeded error threshold" if \
+            errors.size >= THRESHOLDS.fetch("errors")
+          fail DiagnosticError, "Exceeded panic threshold" if panics.size >= 1
+        end
+      end
+    end
+  end
+end