carbon-compiler 0.2.0

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

@@ -0,0 +1,162 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "rainbow"
+
+module Carbon
+  module Compiler
+    class Metanostic
+      # The "mode" of a metanostic or diagnostic.  This determines how a
+      # diagnostic should be treated.
+      module Mode
+        # No mode.  This is rarely used.
+        #
+        # @return [Integer]
+        NONE    = 0x0
+        # Ignore mode.  This means that by default, the diagnostic should be
+        # ignored by the compiler; with a default or less verbose level, the
+        # diagnostic is not output to the compiler.
+        #
+        # @return [Integer]
+        IGNORE  = 0b1
+        # Informational mode.  This means that the diagnostic is output for the
+        # purpose of informing a developer of a certain thing; for example,
+        # the original definition of a function.  At the default verbose level,
+        # it is output to the compiler.
+        #
+        # @return [Integer]
+        INFO    = 0b10
+        # Warning mode.  This means that the diagnostic is output to inform the
+        # developer of a potential issue.  Enough diagnostic warnings causes
+        # a panic.  At the default verbose level, it is output to the compiler.
+        #
+        # @return [Integer]
+        WARNING = 0b100
+        # Error mode.  This means that the diagnostic is output to inform the
+        # developer of a definite issue.  The compiler will not be able to
+        # finish, and enough diagnostic errors causes a panic.  At the default
+        # verbose level, it is output to the compiler.
+        #
+        # @return [Integer]
+        ERROR   = 0b1000
+        # Panic mode.  This means that the diagnostic is output to inform the
+        # developer of a fatal issue.  Once the panic is emitted, all execution
+        # stops, and all diagnostics output.
+        #
+        # @return [Integer]
+        PANIC   = 0b10000
+        # All of the above.  This is mostly used for metanostics to note that
+        # all of the above are allowable modes for a given diagnostic.
+        #
+        # @return [Integer]
+        ALL     = PANIC | ERROR | WARNING | INFO | IGNORE
+
+        # An associative list of modes to convert from strings.
+        #
+        # @return [{String => Integer}]
+        MODES = {
+          "none" => NONE, "ignore" => IGNORE, "info" => INFO,
+          "warning" => WARNING, "error" => ERROR, "panic" => PANIC,
+          "all" => ALL
+        }.freeze
+
+        # Converts from a given value into a mode.  If the value is an array,
+        # the return value of the function is the result of converting each
+        # element into a mode and unioning the result.  If the value is an array,
+        # {MODES} is used to convert the string.  If the value is numeric,
+        # it is returned.
+        #
+        # @raise [ArgumentError] If value is not an Array, a String, or a
+        #   Numeric.
+        # @param value [Array, String, Numeric]
+        # @return [Integer]
+        def self.from(value)
+          if value.is_a?(::Array)
+            from_array(value)
+          elsif value.is_a?(::String)
+            from_string(value)
+          elsif value.is_a?(::Numeric)
+            value
+          else
+            fail ArgumentError, "Unexpected value #{value.class}"
+          end
+        end
+
+        # Converts the given Array value into a mode.  It does this by converting
+        # each element into a mode, and unioning the modes.
+        #
+        # @param value [<String, Numeric>]
+        # @return [Integer]
+        def self.from_array(value)
+          value.inject(NONE) { |a, e| a | from(e) }
+        end
+
+        # Converts the given String value into a mode.  It does this by fetching
+        # the mode from the {MODES} constant.
+        #
+        # @raise KeyError If value is not a valid mode.
+        # @param value [String]
+        # @return [Integer]
+        def self.from_string(value)
+          MODES.fetch(value.downcase)
+        end
+
+        # Checks if the given type is a mode.  This is done by performing a
+        # bitwise and, and comparing the result against zero.  The order of the
+        # arguments does not matter.
+        #
+        # @param mode [Integer] The mode to check against.  This might be the
+        #   allowed modes of a {Metanostic}.
+        # @param type [Integer] The mode to check for.  This might be the new
+        #   default value of a {Metanostic}.
+        # @return [Boolean]
+        def self.is?(mode, type)
+          (mode & type) != 0
+        end
+
+        # Determines if a given mode is a singular mode (i.e. only one of
+        # {IGNORE}. {INFO}, {WARNING}, {ERROR}, or {PANIC}).  It does this
+        # via doing a population count.
+        #
+        # @param mode [Integer]
+        # @return [Boolean]
+        def self.singular?(mode)
+          count = 0
+          ((count += mode & 1) && mode >>= 1) until mode == 0
+          count < 2
+        end
+
+        # Converts the given mode into a string.  If the value is {ALL}, it
+        # retuns `"All"`; if the value is {NONE}, it returns `"None"`;
+        # otherwise, it attempts to find all of the modes that are represented
+        # by the value.
+        #
+        # @return [String]
+        def self.to_s(value)
+          return "All" if value == ALL
+          return "None" if value == NONE
+          MODES.select { |_, v| is?(value, v) && v != ALL }
+               .map(&:first)
+               .map(&:capitalize)
+               .join(", ")
+        end
+
+        # Creates a rainbow representation of the given mode.  The mode must
+        # be singular (see {.singular?}).
+        #
+        # @see https://github.com/sickill/rainbow
+        # @param mode [Integer]
+        # @return [Rainbow]
+        def self.to_rainbow(mode)
+          case mode
+          when IGNORE  then Rainbow("Ignore").color(:white).bright
+          when INFO    then Rainbow("Info").color(:blue).bright
+          when WARNING then Rainbow("Warning").color(:yellow).bright
+          when ERROR   then Rainbow("Error").color(:red).bright
+          when PANIC   then Rainbow("Panic").color(:magenta).bright
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Metanostic
+      # A "State" object.  This manages the state of metanostic modes at any
+      # point in the program.  This is useful for something like the diagnostic
+      # directives, in which `pop`/`push`/`set` operations need to be available
+      # for the metanostic modes.  This manages the metanostic modes.
+      #
+      # The {Metanostic}s are first loaded using {Defaults.defaults}.  They
+      # are then used to generate a "beginning" state or "blank" state.  Their
+      # modes are extracted, resulting in a hash of
+      # `{String => (Integer, Metanostic)}`.  Then, a "current" state is
+      # generated; this is the same hash type as the "beginning" state,
+      # and initially, the same contents.  However, when the `push` operation
+      # occurs, a new "state" is added to the stack, and a new "current" state
+      # is generated, using the beginning state and the stack as a reference.
+      # Whenever a set occurs, it sets to the last state added to the stack,
+      # and a new current state is generated.
+      #
+      # The point of all this is to have a hash at all times that accurately
+      # represents the set modes of all diagnostics.
+      class State
+        extend Forwardable
+        include Enumerable
+
+        # @!method [](name)
+        #   Indexes the state.  Returns an array containing information about
+        #   the mode and the metanostic for the corresponding name, otherwise
+        #   it returns `nil`.
+        #
+        #   @param name [String] The name of the metanostic.
+        #   @return [(Integer, Metanostic)?] The integer is the current mode for
+        #     any diagnostics emitted that derives from the given {Metanostic}.
+        def_delegator :current, :[]
+        # @!method fetch(name, default = CANARY)
+        #   Fetches the {Metanostic} information with the name `name`.  If
+        #   no key exists with the given name, the method will attempt to
+        #   do the following: if a block is given, yield to that; otherwise,
+        #   if a default is given, return that; otherwise, throw a
+        #   `KeyError`.
+        #
+        #   @raise [KeyError] If no block is given and no default is given
+        #     and there is no key `name`.
+        #   @param name [String] The name of the metanostic to look up.
+        #   @return [(Integer, Metanostic), Object] The integer is the current
+        #     mode for any diagnostics emitted that derives from the given
+        #     {Metanostic}.
+        def_delegator :current, :fetch
+        # @!method each
+        #   Iterates over each key-value pair in the current state.
+        #
+        #   @yield [name, data]
+        #   @yieldparam name [String] The name, or key, of the key pair.
+        #   @yieldparam data [(Integer, Metanostic)] The data, or value, of the
+        #     key pair.
+        #   @return [Enumerator]
+        def_delegator :current, :each
+
+        # Initialize the state.  It sets the defaults using {Defaults.defaults},
+        # and generates the beginning state.
+        def initialize
+          @monitor = Monitor.new
+          @defaults = Defaults.defaults
+          @stack = Concurrent::Array.new([Concurrent::Hash.new])
+          generate_beginning
+        end
+
+        # Initializes a copy of the given state.  This is called by `#clone`
+        # and `#dup`, and as such should not be used outside of either of these
+        # things.
+        #
+        # @param state [State] The state to copy from.
+        def initialize_copy(state)
+          @defaults = state.defaults
+          @stack = state.stack.map(&:clone)
+          @monitor = Monitor.new
+          @beginning = state.beginning
+        end
+
+        # Pushes to the stack.  This pushes a clean state to the stack.
+        # This does not change the current state at all, since the new state
+        # is empty.
+        #
+        # @return [void]
+        def push
+          @monitor.synchronize do
+            @stack.push(Concurrent::Hash.new)
+          end
+        end
+
+        # Pops the last state from the stack.  This could potentially change
+        # the state, since the last state may have a new diagnostic setting
+        # inside of it.
+        #
+        # @note This _may_ change the current state.
+        # @return [void]
+        def pop
+          @monitor.synchronize do
+            clear! if @stack.pop.any?
+          end
+        end
+
+        # Sets the given metanostic name to the given metanostic value in the
+        # last state in the stack.  If the metanostic is not found in any of
+        # the defaults, a `KeyError` is raised.  If the new mode is not allowed
+        # for the given metanostic, a {DiagnosticError} is raised.
+        #
+        # @note This changes the current state.
+        # @raise [KeyError] If the metanostic cannot be found.
+        # @raise [DiagnosticError] If the diagnostic could not be set to the
+        #   given mode.
+        # @return [void]
+        def set(name, mode)
+          @monitor.synchronize do
+            mode = Mode.from(mode)
+            metanostic = @defaults.fetch(name)
+            unless metanostic.can_be?(mode)
+              fail DiagnosticError,
+                "Diagnostic #{name} cannot be #{Mode.to_s(mode)}"
+            end
+            @stack.last[metanostic.name] = [mode, metanostic]
+            clear!
+          end
+        end
+
+        # This resets the given metanostic to its default metanostic mode.
+        # It does this by taking the definition from the beginning state and
+        # copying it to the last stack frame.
+        #
+        # @see #set
+        # @note This changes the current state.
+        # @raise (see #set)
+        # @param name [String] The name of the metanostic to reset.
+        # @return (see #set)
+        def reset(name)
+          set(name, @beginning.fetch(name))
+        end
+
+        # The current state.  This is frozen and cached, since it is a derived
+        # value of the beginning state and the stack.
+        #
+        # @return [{String => (Integer, Metanostic)}]
+        def current
+          @_current ||= @monitor.synchronize do
+            @stack.inject(@beginning) { |a, e| a.merge(e) }.freeze
+          end
+        end
+
+      protected
+
+        attr_reader :stack
+        attr_reader :defaults
+        attr_reader :beginning
+
+      private
+
+        def clear!
+          @_current = nil
+        end
+
+        def generate_beginning
+          @beginning = {}
+          @defaults.each do |name, metanostic|
+            @beginning[name] = [metanostic.default, metanostic].freeze
+          end
+          @beginning.freeze
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/metanostic/template.erb

@@ -0,0 +1,11 @@
+<% if file %>
+<%= file.lines.to_a[lines].join("\n") %><%=
+  " " * [@location.column.begin - 1, 0].max %>^<%=
+  (("-" * (distance - 2) + "^") if distance > 2) %>
+
+<% end %><%= Metanostic::Mode.to_rainbow(mode) %>: <%=
+  Rainbow(metanostic.name).color(:cyan).bright %>: <%=
+  Rainbow(location).color(:white).bright %>: <%= message %>
+<% if Carbon.verbose > 1 %><% @stack.each do |frame| %>
+
+	<%= frame %><% end %><% end %>

data/lib/carbon/compiler/node.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/node/base"
+require "carbon/compiler/node/definition"
+require "carbon/compiler/node/etype"
+require "carbon/compiler/node/expression"
+require "carbon/compiler/node/name"
+require "carbon/compiler/node/root"
+require "carbon/compiler/node/statement"
+
+module Carbon
+  module Compiler
+    # The nodes.
+    module Node
+    end
+  end
+end

data/lib/carbon/compiler/node/base.rb

@@ -0,0 +1,213 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    # A base-level node.  Contains all of the basic behaviors that a node
+    # needs.
+    module Node
+      # A base-level node.  Contains all of the basic behaviors that a node
+      # needs.
+      class Base
+        # Creates a "mapping."  This contructs a mapping between a child
+        # and a name.  For example, a for loop has four children: `initial`,
+        # `condition`, `increment`, and `body`.  This creates the association
+        # between the numerical index of the child and the symbolic name
+        # of the child.
+        #
+        # @example
+        #   Statement::For.mapping(initial: 0, condition: 1, increment: 2,
+        #     body: 3)
+        #   Statement::For.new(children).initial # => children[0]
+        # @param data [Hash?] The data for the mapping.  If this is nil,
+        #   the function returns the mapping instead of setting it.
+        # @return [Hash, void]
+        def self.mapping(data = nil)
+          if data.nil?
+            @mapping ||= Concurrent::Hash.new
+          else
+            @mapping = Concurrent::Hash.new.merge(data)
+
+            data.each do |key, value|
+              fail if key == :klass
+              define_method(key) { @children[value] }
+            end
+          end
+        end
+
+        class << self
+          alias_method :attribute, :mapping
+          alias_method :attributes, :mapping
+        end
+
+        include Enumerable
+        extend Forwardable
+
+        # The node's children.  This is most often an array of nodes, but can
+        # sometimes include Scanner tokens as well.
+        #
+        # @return [Array<Node, Scanner::Token>]
+        attr_reader :children
+
+        # The location describing the node.  This is derived solely from the
+        # children that make up the node, and so is considered auxillary.
+        #
+        # @return [Location]
+        attr_reader :location
+
+        # The attributes of a node.  This is mainly used for associating
+        # directives to definitions.  This is empty for most of the lifetime
+        # of a node.
+        #
+        # @return [Array]
+        attr_reader :attributes
+
+        # @!method [](index)
+        #   Access a specific child at the given index.  If a child exists,
+        #   it is returned; otherwise, `nil` is returned.
+        #
+        #   @return [Node, Scanner::Token, nil]
+        def_delegator :children, :[]
+
+        # @!method each
+        #   Yields all children one by one, if a block is given.  It
+        #   then returns an enumerator that enumerates over all of the
+        #   children.
+        #
+        #   @yield [child]
+        #   @yieldparam child [Node, Scanner::Token]
+        #   @return [Enumerator<Node, Scanner::Token>]
+        def_delegator :children, :each
+
+        def_delegator :children, :to_a
+
+        # Initialize the node with the given children and the data.
+        #
+        # @param children [Array<Base>, Scanner::Token] The children of this
+        #   node.
+        # @param data [Hash] The associated data for this node.
+        # @option data [Type] :type (nil) The type of the node.
+        # @option data [Array] :attributes ([]) The attributes of the node.
+        # @option data [Location] :location (nil) The location of the node.
+        # @option data [Array] :components (children) The nodes to derive
+        #   the location of the node from.
+        def initialize(children, data = {})
+          @children = children.dup.freeze
+          @type = data[:type]
+          @attributes = data.fetch(:attributes, [])
+
+          if data.key?(:location)
+            @location = data[:location]
+          else
+            derive_location(data.fetch(:components, children))
+          end
+
+          freeze
+        end
+
+        # Sets the attributes of a copy of this node to the given attributes.
+        # It then returns the copy.
+        #
+        # @param attributes [Array]
+        # @return [Base]
+        def attributes!(attributes)
+          self.class.new(children, data.merge(attributes: attributes))
+        end
+
+        # Sets the type of a copy of this node to the given type.
+        # It then returns the copy.
+        #
+        # @param type [Type]
+        # @return [Base]
+        def type!(type)
+          self.class.new(children, data.merge(type: type))
+        end
+
+        # Sets the children of a copy of this node to the given children.
+        # It then returns the copy.
+        #
+        # @param children [Array]
+        # @return [Base]
+        def update!(children)
+          self.class.new(children, data)
+        end
+        alias_method :update, :update!
+
+        # Maps the children using the given block.  It then returns a copy of
+        # the node with the new children.
+        #
+        # @param children [::Array]
+        # @return [Base]
+        def map!
+          update!(children.map(&Proc.new))
+        end
+
+        # Using the {ClassMethods#mapping}, it merges the given hash into
+        # the children.
+        #
+        # @example
+        #   Statement::For.mapping(initial: 0, condition: 1, increment: 2,
+        #     body: 3)
+        #   stmt = Statement::For.new(children)
+        #   stmt.merge!(initial: initial).initial # => initial
+        # @param options [{Symbol => Base}]
+        # @return [Base]
+        def merge!(options)
+          merged = @children.dup
+          options.each do |key, value|
+            merged[attributes.fetch(key)] = value
+          end
+
+          update!(merged)
+        end
+
+        alias_method :merge, :merge!
+
+        # Accepts the current visitor unto itself.
+        #
+        # @param visitor [#visit]
+        # @return [Object]
+        def accept(visitor, *arguments)
+          visitor.visit(self, *arguments)
+        end
+
+        # Returns true if this node is a data definition.
+        #
+        # @return [Boolean]
+        def data?
+          false
+        end
+
+        # Returns true if this node is a behavior definition.
+        #
+        # @return [Boolean]
+        def behavior?
+          false
+        end
+
+        # Returns true if this node is an identity definition.
+        #
+        # @return [Boolean]
+        def identity?
+          false
+        end
+
+        def data
+          { location: @location, attributes: @attributes, type: @type }
+        end
+
+      private
+
+        def attributes
+          self.class.attributes
+        end
+
+        def derive_location(children)
+          @location = children.flatten.compact
+                      .select { |c| c.respond_to?(:location) }
+                      .map(&:location).inject(:|)
+        end
+      end
+    end
+  end
+end