ridl 2.8.2 → 2.10.0

data/lib/ridl/node.rb

@@ -10,7 +10,6 @@
 # Copyright (c) Remedy IT Expertise BV
 #--------------------------------------------------------------------
 module IDL::AST
-
   REPO_ID_XCHARS = ['.', '-', '_']
   REPO_ID_RE = /^[#{('a'..'z').to_a.join}#{('A'..'Z').to_a.join}#{('0'..'9').to_a.join}\.\-_\/]+$/
 
@@ -75,16 +74,13 @@ module IDL::AST
     end
 
     def concat(anns)
-      anns.each {|_ann| self << _ann } if anns
+      anns.each { |_ann| self << _ann } if anns
     end
   end
 
   class Leaf
-    attr_reader :name, :intern
+    attr_reader :name, :intern, :scopes, :prefix, :annotations
     attr_accessor :enclosure
-    attr_reader :scopes
-    attr_reader :prefix
-    attr_reader :annotations
 
     def typename
       self.class.name
@@ -117,7 +113,7 @@ module IDL::AST
     end
 
     def scoped_name
-      @scoped_name ||= @scopes.collect{|s| s.name}.join("::").freeze
+      @scoped_name ||= @scopes.collect { |s| s.name }.join("::").freeze
     end
 
     def scoped_lm_name
@@ -200,7 +196,7 @@ module IDL::AST
         @repo_ver = "1.0" unless @repo_ver
         format("IDL:%s%s:%s",
                 if @prefix.empty? then "" else @prefix + "/" end,
-                self.scopes.collect{|s| s.name}.join("/"),
+                self.scopes.collect { |s| s.name }.join("/"),
                 @repo_ver)
       else
         @repo_id
@@ -237,7 +233,7 @@ module IDL::AST
   class Node < Leaf
     def initialize(name, enclosure)
       super
-      @introduced = Hash.new
+      @introduced = {}
       @children = []
       introduce(self)
     end
@@ -261,7 +257,7 @@ module IDL::AST
       @introduced.delete(node.intern)
     end
 
-    def redefine(node, params)
+    def redefine(node, _params)
       raise "\"#{node.name}\" is already defined."
     end
 
@@ -271,10 +267,11 @@ module IDL::AST
       end
     end
 
-    def define(_type, _name, params = Hash.new)
-      if not is_definable?(_type)
-        raise "#{_type.to_s} is not definable in #{self.typename}."
+    def define(_type, _name, params = {})
+      unless is_definable?(_type)
+        raise "#{_type} is not definable in #{self.typename}."
       end
+
       node = search_self(_name)
       if node.nil?
         node = _type.new(_name, self, params)
@@ -286,6 +283,7 @@ module IDL::AST
         if _type != node.class
           raise "#{_name} is already defined as a type of #{node.typename}"
         end
+
         node = redefine(node, params)
       end
       node
@@ -325,6 +323,7 @@ module IDL::AST
       if not node.nil? and node.name != _name
         raise "\"#{_name}\" clashed with \"#{node.name}\"."
       end
+
       node
     end
 
@@ -383,14 +382,20 @@ module IDL::AST
   class UnionMember < Member; end
   class Enum < Leaf; end
   class Enumerator < Leaf; end
+  class BitMask < Node; end
+  class BitValue < Leaf; end
+  class BitSet < Node; end
+  class BitField < Leaf; end
 
   class Module < Node
     DEFINABLE = [
       IDL::AST::Module, IDL::AST::Interface, IDL::AST::Valuebox, IDL::AST::Valuetype, IDL::AST::Const, IDL::AST::Struct,
       IDL::AST::Union, IDL::AST::Enum, IDL::AST::Enumerator, IDL::AST::Typedef, IDL::AST::Include,
-      IDL::AST::Home, IDL::AST::Porttype, IDL::AST::Component, IDL::AST::Connector
+      IDL::AST::Home, IDL::AST::Porttype, IDL::AST::Component, IDL::AST::Connector, IDL::AST::BitMask, IDL::AST::BitValue,
+      IDL::AST::BitSet, IDL::AST::BitField
     ]
     attr_reader :anchor, :next, :template, :template_params
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @anchor = params[:anchor]
@@ -410,6 +415,7 @@ module IDL::AST
 
     def template_param(param)
       return nil unless @template
+
       param = param.to_s if ::Symbol === param
       if ::String === param
         @template.params.each_with_index do |tp, ix|
@@ -455,7 +461,7 @@ module IDL::AST
         _anchor = node.has_anchor? ? node.anchor : node
         _anchor.annotations.concat(params.delete(:annotations))
         _last = _anchor.find_last
-        _params = params.merge({ :anchor => _anchor, :prefix => node.prefix })
+        _params = params.merge({ anchor: _anchor, prefix: node.prefix })
         _next = IDL::AST::Module.new(node.name, self, _params)
         _last.set_next(_next)
         @children << _next
@@ -548,7 +554,7 @@ module IDL::AST
     end
 
     def replace_prefix(pfx)
-      self.prefix = pfx   # handles validation
+      self.prefix = pfx # handles validation
       if @anchor.nil?
         self.replace_prefix_i(pfx)
       else
@@ -578,6 +584,7 @@ module IDL::AST
         cp = IDL::AST::TemplateParam.concrete_param(instantiation_context, _template.anchor)
         # concrete param must be a IDL::Type::NodeType and it's node a Module (should never fail)
         raise "Invalid concrete anchor found" unless cp.is_a?(IDL::Type::NodeType) && cp.node.is_a?(IDL::AST::Module)
+
         @anchor = cp.node
         # link our self into module chain
         @anchor.find_last.set_next(self)
@@ -608,6 +615,7 @@ module IDL::AST
       if not node.nil? and node.name != _name
         raise "\"#{_name}\" clashed with \"#{node.name}\"."
       end
+
       if node.nil? && @next
         node = @next.search_links(_name)
       end
@@ -633,6 +641,7 @@ module IDL::AST
 
   class TemplateParam < Leaf
     attr_reader :idltype, :concrete
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype = params[:type]
@@ -667,7 +676,7 @@ module IDL::AST
     def self.concrete_param(instantiation_context, tpl_elem)
       # is this an element from the template's scope
       if tpl_elem.is_template?
-        celem = if tpl_elem.is_a?(IDL::AST::TemplateParam)  # an actual template parameter?
+        celem = if tpl_elem.is_a?(IDL::AST::TemplateParam) # an actual template parameter?
           tpl_elem.concrete # get the template parameter's concrete (instantiation argument) value
         else
           # referenced template elements should have been instantiated already and available through context
@@ -677,6 +686,7 @@ module IDL::AST
           ctxelem.is_a?(IDL::AST::Const) ? ctxelem.expression : ctxelem.idltype
         end
         raise "cannot resolve concrete node for template #{tpl_elem.typename} #{tpl_elem.scoped_lm_name}" unless celem
+
         celem
       else
         tpl_elem.idltype # just return the element's idltype if not from the template scope
@@ -692,6 +702,7 @@ module IDL::AST
       IDL::AST::TemplateParam, IDL::AST::TemplateModuleReference
     ]
     attr_reader :idltype
+
     def initialize(_name, _enclosure, _params)
       super(_name, _enclosure, {})
       @idltype = IDL::Type::TemplateModule.new(self)
@@ -716,6 +727,7 @@ module IDL::AST
       # process concrete parameters
       @template_params.each_with_index do |_tp, _ix|
         raise "missing template parameter for #{typename} #{scoped_lm_name}: #{_tp.name}" unless _ix < _module_instance.template_params.size
+
         _cp = _module_instance.template_params[_ix]
         if _cp.is_a?(IDL::Type)
           raise "anonymous type definitions are not allowed!" if _cp.is_anonymous?
@@ -723,6 +735,7 @@ module IDL::AST
           unless _tp.idltype.is_a?(IDL::Type::Any) || _tp.idltype.class === _cp.resolved_type
             raise "mismatched instantiation parameter \##{_ix} #{_cp.typename} for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
           end
+
           # verify concrete parameter
           case _tp.idltype
             when IDL::Type::Any # 'typename'
@@ -734,10 +747,12 @@ module IDL::AST
                  IDL::Type::Union, # 'union'
                  IDL::Type::Exception, # 'exception'
                  IDL::Type::Enum # 'enum'
+                 IDL::Type::BitMask# 'bitmask'
+                 IDL::Type::BitSet# 'bitset'
                # no further checks
             when IDL::Type::Sequence # 'sequence' or 'sequence<...>'
               _tptype = _tp.idltype
-              unless _tptype.basetype.is_a?(IDL::Type::Void)  # 'sequence'
+              unless _tptype.basetype.is_a?(IDL::Type::Void) # 'sequence'
                 # check basetype
                 unless _tptype.basetype.is_a?(IDL::Type::ScopedName) &&
                        _tptype.basetype.is_node?(IDL::AST::TemplateParam) &&
@@ -751,6 +766,7 @@ module IDL::AST
           unless _tp.idltype.is_a?(IDL::Type::Const)
             raise "unexpected expression as instantiation parameter for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
           end
+
           # match constant type
           _tp.idltype.narrow(_cp.value)
         else
@@ -765,7 +781,7 @@ module IDL::AST
 
   protected
 
-    def walk_members_for_copy(&block)
+    def walk_members_for_copy
       @children.each { |c| yield(c) unless c.is_a?(IDL::AST::TemplateParam) }
     end
   end # TemplateModule
@@ -776,6 +792,7 @@ module IDL::AST
       unless _params[:tpl_type].is_a?(IDL::Type::ScopedName) && _params[:tpl_type].is_node?(IDL::AST::TemplateModule)
         raise "templated module reference type required for #{typename} #{scoped_lm_name}: got #{_params[:tpl_type].typename}"
       end
+
       @template = _params[:tpl_type].resolved_type.node
       _params[:tpl_params].each do |p|
         unless (p.is_a?(IDL::Type::ScopedName) || p.is_a?(IDL::Expression::ScopedName)) && p.is_node?(IDL::AST::TemplateParam)
@@ -800,7 +817,7 @@ module IDL::AST
         # concrete objects are either Expression or Type
         tp.concrete
       end
-      mod_inst = IDL::AST::Module.new(self.name, _enclosure, { :template => @template, :template_params => inst_params })
+      mod_inst = IDL::AST::Module.new(self.name, _enclosure, { template: @template, template_params: inst_params })
       @template.instantiate(mod_inst, instantiation_context)
       mod_inst
     end
@@ -812,15 +829,16 @@ module IDL::AST
 
   class Include < Module
     attr_reader :filename, :fullpath
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure, params)
       @filename = params[:filename]
       @fullpath = params[:fullpath]
       @defined = params[:defined] || false
       @preprocessed = params[:preprocessed] || false
-      #overrule
+      # overrule
       @scopes = @enclosure.scopes
-      @scoped_name = @scopes.collect{|s| s.name}.join("::")
+      @scoped_name = @scopes.collect { |s| s.name }.join("::")
     end
 
     def lm_scopes
@@ -836,13 +854,18 @@ module IDL::AST
       @defined = vars.pop
       @filename = vars.pop
       super(vars)
-      #overrule
+      # overrule
       @scopes = @enclosure.scopes || []
-      @scoped_name = @scopes.collect{|s| s.name}.join("::")
+      @scoped_name = @scopes.collect { |s| s.name }.join("::")
     end
 
-    def is_defined?; @defined; end
-    def is_preprocessed?; @preprocessed; end
+    def is_defined?
+      @defined
+    end
+
+    def is_preprocessed?
+      @preprocessed
+    end
 
     def introduce(node)
       @enclosure.introduce(node) unless node == self
@@ -862,9 +885,9 @@ module IDL::AST
       @filename = _template.filename
       @defined = _template.is_defined?
       @preprocessed = _template.is_preprocessed?
-      #overrule
+      # overrule
       @scopes = @enclosure.scopes
-      @scoped_name = @scopes.collect{|s| s.name}.join("::")
+      @scoped_name = @scopes.collect { |s| s.name }.join("::")
       self
     end
 
@@ -874,7 +897,6 @@ module IDL::AST
   end # Include
 
   class Derivable < Node
-
     alias :search_self_before_derived :search_self
     def search_self(_name)
       node = search_self_before_derived(_name)
@@ -895,6 +917,7 @@ module IDL::AST
     def each_ancestors(visited = [], &block)
       resolved_bases.each do |p|
         next if visited.include? p
+
         yield(p)
         visited.push p
         p.each_ancestors(visited, &block)
@@ -911,8 +934,9 @@ module IDL::AST
       if results.size > 1
         # check if the matched name resulted in multiple different nodes or all the same
         r_one = results.shift
-        unless results.all? {|r| r_one == r || (r_one.class == r.class && r_one.scoped_name == r.scoped_name) }
-          s = results.inject([r_one]) {|l, r| l << r unless l.include?(r); l }.collect{ |n| n.scoped_name }.join(", ")
+        unless results.all? { |r| r_one == r || (r_one.class == r.class && r_one.scoped_name == r.scoped_name) }
+          s = results.inject([r_one]) { |l, r| l << r unless l.include?(r)
+ l }.collect { |n| n.scoped_name }.join(", ")
           raise "\"#{_name}\" is ambiguous. " + s
         end
       end
@@ -945,8 +969,7 @@ module IDL::AST
   class Interface < Derivable
     DEFINABLE = [IDL::AST::Const, IDL::AST::Operation, IDL::AST::Attribute,
                  IDL::AST::Struct, IDL::AST::Union, IDL::AST::Typedef, IDL::AST::Enum, IDL::AST::Enumerator]
-    attr_reader :bases
-    attr_reader :idltype
+    attr_reader :bases, :idltype
 
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
@@ -977,22 +1000,36 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :forward => self.is_forward?,
-        :abstract => self.is_abstract?,
-        :pseudo => self.is_pseudo?,
-        :local => self.is_local?,
-        :inherits => self.concrete_bases(instantiation_context)
+        forward: self.is_forward?,
+        abstract: self.is_abstract?,
+        pseudo: self.is_pseudo?,
+        local: self.is_local?,
+        inherits: self.concrete_bases(instantiation_context)
       }
       # instantiate concrete interface def and validate
       # concrete bases
       super(instantiation_context, _enclosure, _params)
     end
 
-    def is_abstract?; @abstract; end
-    def is_local?; @local; end
-    def is_pseudo?; @pseudo; end
-    def is_defined?; @defined; end
-    def is_forward?; not @defined; end
+    def is_abstract?
+      @abstract
+    end
+
+    def is_local?
+      @local
+    end
+
+    def is_pseudo?
+      @pseudo
+    end
+
+    def is_defined?
+      @defined
+    end
+
+    def is_forward?
+      not @defined
+    end
 
     def add_bases(inherits_)
       inherits_.each do |tc|
@@ -1000,11 +1037,12 @@ module IDL::AST
           unless (tc.is_a?(IDL::Type::NodeType) && tc.is_node?(IDL::AST::Interface))
             raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
           end
+
           rtc = tc.resolved_type
           if rtc.node.has_ancestor?(self)
             raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
           end
-          if not rtc.node.is_defined?
+          unless rtc.node.is_defined?
             raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if rtc.node.is_local? and not self.is_local?
@@ -1022,6 +1060,7 @@ module IDL::AST
           if self.has_base?(rtc.node)
             raise "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
           end
+
           # check if we indirectly derive from this base multiple times (which is ok; no further need to check)
           unless @resolved_bases.any? { |b| b.has_ancestor?(rtc.node) }
             # this is a new base so we need to check for member redefinition/ambiguity
@@ -1029,7 +1068,8 @@ module IDL::AST
             rtc.node.walk_members do |m|
               new_op_att_ << m if m.is_a?(IDL::AST::Operation) || m.is_a?(IDL::AST::Attribute)
             end
-            if new_op_att_.any? {|n| n_ = self.search_self(n.name); n_.is_a?(IDL::AST::Operation) || n_.is_a?(IDL::AST::Attribute) }
+            if new_op_att_.any? { |n| n_ = self.search_self(n.name)
+ n_.is_a?(IDL::AST::Operation) || n_.is_a?(IDL::AST::Attribute) }
               raise "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
             end
             # no need to check for duplicate member names; this inheritance is ok
@@ -1048,13 +1088,13 @@ module IDL::AST
       @resolved_bases
     end
 
-    def operations(include_bases=false, traversed=nil)
+    def operations(include_bases = false, traversed = nil)
       ops = @children.find_all { |c| c.is_a?(IDL::AST::Operation) }
       ops.concat(base_operations(traversed || [])) if include_bases
       ops
     end
 
-    def attributes(include_bases=false, traversed=nil)
+    def attributes(include_bases = false, traversed = nil)
       atts = @children.find_all { |c| c.is_a?(IDL::AST::Attribute) }
       atts.concat(base_attributes(traversed || [])) if include_bases
       atts
@@ -1067,6 +1107,7 @@ module IDL::AST
           if node.is_defined?
             raise "#{node.typename} \"#{node.name}\" is already defined."
           end
+
           node.annotations.concat(params[:annotations])
 
           _new_node = node.class.new(node.name, self, params)
@@ -1095,7 +1136,7 @@ module IDL::AST
         newnode = node.class.new(node.name, self, params)
         newnode.annotations.concat(params[:annotations])
         introduce(newnode)
-        @children << newnode  # add overriding child
+        @children << newnode # add overriding child
         return newnode
       end
     end
@@ -1116,9 +1157,7 @@ module IDL::AST
 
   class ComponentBase < Derivable
     DEFINABLE = []
-    attr_reader :base
-    attr_reader :interfaces
-    attr_reader :idltype
+    attr_reader :base, :interfaces, :idltype
 
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
@@ -1145,8 +1184,8 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure, _params = {})
       _params.merge!({
-        :base => @base ? IDL::AST::TemplateParam.concrete_param(instantiation_context, @base) : @base,
-        :supports => self.concrete_interfaces(instantiation_context)
+        base: @base ? IDL::AST::TemplateParam.concrete_param(instantiation_context, @base) : @base,
+        supports: self.concrete_interfaces(instantiation_context)
       })
       # instantiate concrete def and validate
       super(instantiation_context, _enclosure, _params)
@@ -1160,6 +1199,7 @@ module IDL::AST
         if parent.resolved_type.node.has_base?(self)
           raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
         end
+
         @resolved_base = parent.resolved_type.node
       end
       @base = parent.node
@@ -1179,8 +1219,9 @@ module IDL::AST
           unless (tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::Interface))
             raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
           end
+
           rtc = tc.resolved_type
-          if not rtc.node.is_defined?
+          unless rtc.node.is_defined?
             raise "#{typename} #{scoped_lm_name} cannot support forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           ## TODO : is this legal?
@@ -1191,13 +1232,14 @@ module IDL::AST
             raise "#{typename} #{scoped_lm_name} cannot support 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           ## TODO : is this legal?
-          #if tc.node.is_abstract?
+          # if tc.node.is_abstract?
           #  raise RuntimeError,
           #        "'abstract' #{typename} #{scoped_lm_name} cannot support 'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
-          #end
+          # end
           if self.has_support?(rtc.node)
             raise "#{typename} #{scoped_lm_name} cannot support #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
           end
+
           # check if we indirectly support this base multiple times (which is ok; no further need to check)
           unless @resolved_interfaces.any? { |b| b.has_ancestor?(rtc.node) }
             # this is a new support interface so we need to check for member redefinition/ambiguity
@@ -1205,7 +1247,8 @@ module IDL::AST
             rtc.node.walk_members do |m|
               new_op_att_ << m if m.is_a?(IDL::AST::Operation) || m.is_a?(IDL::AST::Attribute)
             end
-            if new_op_att_.any? {|n| n_ = self.search_self(n.name); n_.is_a?(IDL::AST::Operation) || n_.is_a?(IDL::AST::Attribute) }
+            if new_op_att_.any? { |n| n_ = self.search_self(n.name)
+ n_.is_a?(IDL::AST::Operation) || n_.is_a?(IDL::AST::Attribute) }
               raise "#{typename} #{scoped_lm_name} cannot support #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
             end
             # no need to check for duplicate member names; this support is ok
@@ -1231,6 +1274,7 @@ module IDL::AST
           if node.is_defined?
             raise "#{node.typename} \"#{node.name}\" is already defined."
           end
+
           node.annotations.concat(params[:annotations])
 
           _new_node = node.class.new(node.name, self, params)
@@ -1259,7 +1303,7 @@ module IDL::AST
         newnode = node.class.new(node.name, self, params)
         newnode.annotations.concat(params[:annotations])
         introduce(newnode)
-        @children << newnode  # add overriding child
+        @children << newnode # add overriding child
         return newnode
       end
     end
@@ -1281,8 +1325,7 @@ module IDL::AST
   class Home < ComponentBase
     DEFINABLE = [IDL::AST::Const, IDL::AST::Operation, IDL::AST::Attribute, IDL::AST::Initializer, IDL::AST::Finder,
                  IDL::AST::Struct, IDL::AST::Union, IDL::AST::Typedef, IDL::AST::Enum, IDL::AST::Enumerator]
-    attr_reader :component
-    attr_reader :primarykey
+    attr_reader :component, :primarykey
 
     def initialize(_name, _enclosure, params)
       @component = nil
@@ -1307,9 +1350,9 @@ module IDL::AST
     end
 
     def instantiate(instantiation_context, _enclosure)
-      _params  = {
-        :component => IDL::AST::TemplateParam.concrete_param(instantiation_context, @component),
-        :primarykey => @primarykey ? IDL::AST::TemplateParam.concrete_param(instantiation_context, @primarykey) : @primarykey
+      _params = {
+        component: IDL::AST::TemplateParam.concrete_param(instantiation_context, @component),
+        primarykey: @primarykey ? IDL::AST::TemplateParam.concrete_param(instantiation_context, @primarykey) : @primarykey
       }
       # instantiate concrete home def and validate
       super(instantiation_context, _enclosure, _params)
@@ -1325,6 +1368,7 @@ module IDL::AST
         unless comp.resolved_type.node.is_defined?
           raise "#{scoped_lm_name}: #{comp.typename} cannot manage forward declared component #{comp.node.scoped_lm_name}"
         end
+
         @resolved_comp = comp.resolved_type.node
       end
       unless key&.is_a?(IDL::Type::ScopedName) && key.is_node?(IDL::AST::TemplateParam)
@@ -1332,24 +1376,24 @@ module IDL::AST
         unless key.nil? || (key.is_a?(IDL::Type::ScopedName) && key.is_node?(IDL::AST::Valuetype))
           raise "invalid primary key for #{typename} #{scoped_lm_name}: #{key.typename}"
         end
+
         @resolved_pk = key.resolved_type.node if key
       end
       @component = comp.node
       @primarykey = key.node if key
     end
 
-    def operations(include_bases=false, traversed=nil)
+    def operations(include_bases = false, traversed = nil)
       ops = @children.find_all { |c| c.is_a?(IDL::AST::Operation) }
       ops.concat(base_operations(traversed || [])) if include_bases
       ops
     end
 
-    def attributes(include_bases=false, traversed=nil)
+    def attributes(include_bases = false, traversed = nil)
       atts = @children.find_all { |c| c.is_a?(IDL::AST::Attribute) }
       atts.concat(base_attributes(traversed || [])) if include_bases
       atts
     end
-
   end # Home
 
   class Connector < ComponentBase
@@ -1373,8 +1417,13 @@ module IDL::AST
       super(instantiation_context, _enclosure, {})
     end
 
-    def is_defined?; true; end
-    def is_forward?; false; end
+    def is_defined?
+      true
+    end
+
+    def is_forward?
+      false
+    end
 
     def add_interfaces(intfs)
       raise "interface support not allowed for #{typename} #{scoped_lm_name}" if intfs && !intfs.empty?
@@ -1385,6 +1434,7 @@ module IDL::AST
         unless (parent.is_a?(IDL::Type::NodeType) && parent.is_node?(self.class))
           raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
         end
+
         @resolved_base = parent.resolved_type.node
         if @resolved_base.has_base?(self)
           raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
@@ -1393,7 +1443,7 @@ module IDL::AST
       @base = parent.node
     end
 
-    def ports(include_bases=false, traversed=nil)
+    def ports(include_bases = false, traversed = nil)
       ports = @children.inject([]) do |lst, c|
         lst.concat(c.ports) if IDL::AST::Port === c
         lst
@@ -1402,7 +1452,7 @@ module IDL::AST
       ports
     end
 
-    def attributes(include_bases=false, traversed=nil)
+    def attributes(include_bases = false, traversed = nil)
       atts = @children.inject([]) do |lst, c|
         if IDL::AST::Port === c
           lst.concat(c.attributes)
@@ -1427,7 +1477,6 @@ module IDL::AST
       end
       ports
     end
-
   end # Connector
 
   class Component < ComponentBase
@@ -1450,19 +1499,25 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       # instantiate concrete component def and validate
-      super(instantiation_context, _enclosure, { :forward => self.is_forward? })
+      super(instantiation_context, _enclosure, { forward: self.is_forward? })
     end
 
-    def is_defined?; @defined; end
-    def is_forward?; not @defined; end
+    def is_defined?
+      @defined
+    end
+
+    def is_forward?
+      not @defined
+    end
 
     def set_base(parent)
       unless parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(IDL::AST::TemplateParam)
         unless (parent.is_a?(IDL::Type::NodeType) && parent.is_node?(self.class))
           raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
         end
+
         @resolved_base = parent.resolved_type.node
-        if not @resolved_base.is_defined?
+        unless @resolved_base.is_defined?
           raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{parent.node.typename} #{parent.node.scoped_lm_name}"
         end
         if @resolved_base.has_base?(self)
@@ -1472,7 +1527,7 @@ module IDL::AST
       @base = parent.node
     end
 
-    def ports(include_bases=false, traversed=nil)
+    def ports(include_bases = false, traversed = nil)
       ports = @children.inject([]) do |lst, c|
         lst.concat(c.ports) if IDL::AST::Port === c
         lst
@@ -1481,11 +1536,11 @@ module IDL::AST
       ports
     end
 
-    def operations(include_bases=false, traversed=nil)
+    def operations(include_bases = false, traversed = nil)
       include_bases ? base_operations(traversed || []) : []
     end
 
-    def attributes(include_bases=false, traversed=nil)
+    def attributes(include_bases = false, traversed = nil)
       atts = @children.inject([]) do |lst, c|
         if IDL::AST::Port === c
           lst.concat(c.attributes)
@@ -1510,23 +1565,23 @@ module IDL::AST
       end
       ports
     end
-
   end # Component
 
   class Porttype < Node
     DEFINABLE = [IDL::AST::Attribute, IDL::AST::Port]
     attr_reader :idltype
-    def initialize(_name, _enclosure, params)
+
+    def initialize(_name, _enclosure, _params)
       super(_name, _enclosure)
       @idltype = IDL::Type::Porttype.new(self)
     end
 
     def ports
-      @children.select {|c| IDL::AST::Port === c}
+      @children.select { |c| IDL::AST::Port === c }
     end
 
     def attributes
-      @children.select {|c| IDL::AST::Attribute === c}
+      @children.select { |c| IDL::AST::Attribute === c }
     end
 
     def instantiate(instantiation_context, _enclosure)
@@ -1536,15 +1591,16 @@ module IDL::AST
 
   class Port < Leaf
     PORTTYPES = [:facet, :receptacle, :emitter, :publisher, :consumer, :port, :mirrorport]
-    PORT_MIRRORS = {:facet => :receptacle, :receptacle => :facet}
+    PORT_MIRRORS = {facet: :receptacle, receptacle: :facet}
     EXTPORTDEF_ANNOTATION = 'ExtendedPortDef'
-    attr_reader :idltype
-    attr_reader :porttype
+    attr_reader :idltype, :porttype
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype  = params[:type]
       @porttype = params[:porttype]
       raise "unknown porttype for  #{typename} #{scoped_lm_name}: #{@porttype}" unless PORTTYPES.include?(@porttype)
+
       case @porttype
       when :facet, :receptacle
         unless @idltype.is_a?(IDL::Type::Object) ||
@@ -1565,9 +1621,9 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(instantiation_context),
-        :porttype => @porttype,
-        :multiple => @multiple
+        type: @idltype.instantiate(instantiation_context),
+        porttype: @porttype,
+        multiple: @multiple
       }
       super(instantiation_context, _enclosure, _params)
     end
@@ -1577,23 +1633,23 @@ module IDL::AST
     end
 
     def expanded_copy(name_pfx, enc)
-      p = IDL::AST::Port.new("#{name_pfx}_#{self.name}", enc, {:type => @idltype, :porttype => @porttype})
-      p.annotations << Annotation.new(EXTPORTDEF_ANNOTATION, { :extended_port_name => name_pfx, :base_name => self.name, :mirror => false })
+      p = IDL::AST::Port.new("#{name_pfx}_#{self.name}", enc, {type: @idltype, porttype: @porttype})
+      p.annotations << Annotation.new(EXTPORTDEF_ANNOTATION, { extended_port_name: name_pfx, base_name: self.name, mirror: false })
       p # return expanded copy
     end
 
     def expanded_mirror_copy(name_pfx, enc)
-      p = IDL::AST::Port.new("#{name_pfx}_#{self.name}", enc, {:type => @idltype, :porttype => PORT_MIRRORS[@porttype]})
-      p.annotations << Annotation.new(EXTPORTDEF_ANNOTATION, { :extended_port_name => name_pfx, :base_name => self.name, :mirror => true })
+      p = IDL::AST::Port.new("#{name_pfx}_#{self.name}", enc, {type: @idltype, porttype: PORT_MIRRORS[@porttype]})
+      p.annotations << Annotation.new(EXTPORTDEF_ANNOTATION, { extended_port_name: name_pfx, base_name: self.name, mirror: true })
       p # return expanded copy
     end
 
     def ports
       case @porttype
       when :port
-        @idltype.resolved_type.node.ports.collect {|p| p.expanded_copy(self.name, self.enclosure) }
+        @idltype.resolved_type.node.ports.collect { |p| p.expanded_copy(self.name, self.enclosure) }
       when :mirrorport
-        @idltype.resolved_type.node.ports.collect {|p| p.expanded_mirror_copy(self.name, self.enclosure) }
+        @idltype.resolved_type.node.ports.collect { |p| p.expanded_mirror_copy(self.name, self.enclosure) }
       else
         [self]
       end
@@ -1602,9 +1658,9 @@ module IDL::AST
     def attributes
       case @porttype
       when :port, :mirrorport
-        @idltype.resolved_type.node.attributes.collect {|att|
+        @idltype.resolved_type.node.attributes.collect { |att|
           exp_a = att.expanded_copy(self.name, self.enclosure)
-          exp_a.annotations << Annotation.new(EXTPORTDEF_ANNOTATION, { :extended_port_name => self.name, :base_name => att.name, :mirror => (@porttype == :mirrorport) })
+          exp_a.annotations << Annotation.new(EXTPORTDEF_ANNOTATION, { extended_port_name: self.name, base_name: att.name, mirror: (@porttype == :mirrorport) })
           exp_a # return expanded copy
         }
       else
@@ -1615,10 +1671,11 @@ module IDL::AST
 
   class Valuebox < Leaf
     attr_reader :idltype, :boxed_type
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype = IDL::Type::Valuebox.new(self)
-      @boxed_type  = params[:type]
+      @boxed_type = params[:type]
       unless @boxed_type.is_a?(IDL::Type::ScopedName) && @boxed_type.is_node?(IDL::AST::TemplateParam)
         if @boxed_type.resolved_type.is_a?(IDL::Type::Valuetype)
           raise "boxing valuetype #{@boxed_type.scoped_lm_name} in Valuebox #{scoped_lm_name} not allowed"
@@ -1642,7 +1699,7 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @boxed_type.instantiate(instantiation_context)
+        type: @boxed_type.instantiate(instantiation_context)
       }
       super(instantiation_context, _enclosure, _params)
     end
@@ -1651,8 +1708,7 @@ module IDL::AST
   class Valuetype < Derivable
     DEFINABLE = [IDL::AST::Include, IDL::AST::Const, IDL::AST::Operation, IDL::AST::Attribute, IDL::AST::StateMember, IDL::AST::Initializer,
                  IDL::AST::Struct, IDL::AST::Union, IDL::AST::Typedef, IDL::AST::Enum, IDL::AST::Enumerator]
-    attr_reader :bases, :interfaces
-    attr_reader :idltype
+    attr_reader :bases, :interfaces, :idltype
 
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
@@ -1677,6 +1733,7 @@ module IDL::AST
         if @custom && @truncatable
             raise "'truncatable' attribute *not* allowed for 'custom' #{typename} #{scoped_lm_name}"
         end
+
         add_bases(_base[:list] || [])
         add_interfaces(_inherits[:supports] || [])
       end
@@ -1707,15 +1764,15 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :forward => self.is_forward?,
-        :abstract => self.is_abstract?,
-        :custom => self.is_custom?,
-        :inherits => {
-          :base => {
-            :truncatable => self.is_truncatable?,
-            :list => self.concrete_bases(instantiation_context)
+        forward: self.is_forward?,
+        abstract: self.is_abstract?,
+        custom: self.is_custom?,
+        inherits: {
+          base: {
+            truncatable: self.is_truncatable?,
+            list: self.concrete_bases(instantiation_context)
           },
-          :supports => self.concrete_interfaces(instantiation_context)
+          supports: self.concrete_interfaces(instantiation_context)
         }
       }
       inst = super(instantiation_context, _enclosure, _params)
@@ -1723,19 +1780,43 @@ module IDL::AST
       inst
     end
 
-    def is_abstract?; @abstract; end
-    def is_custom?; @custom; end
-    def is_truncatable?; @truncatable; end
-    def is_defined?; @defined; end
-    def defined=(f); @defined = f; end
-    def is_forward?; @forward; end
-    def is_recursive?; @recursive end
-    def recursive=(f); @recursive = f end
+    def is_abstract?
+      @abstract
+    end
+
+    def is_custom?
+      @custom
+    end
+
+    def is_truncatable?
+      @truncatable
+    end
+
+    def is_defined?
+      @defined
+    end
+
+    def defined=(f)
+      @defined = f
+    end
+
+    def is_forward?
+      @forward
+    end
+
+    def is_recursive?
+      @recursive
+    end
+
+    def recursive=(f)
+      @recursive = f
+    end
 
     def is_local?(recurstk = [])
       # not local if forward decl or recursion detected
       return false if is_forward? || recurstk.include?(self)
-      recurstk.push self   # track root node to detect recursion
+
+      recurstk.push self # track root node to detect recursion
       ret = state_members.any? { |m| m.is_local?(recurstk) }
       recurstk.pop
       ret
@@ -1766,22 +1847,23 @@ module IDL::AST
     end
 
     def truncatable_ids
-      ids = [self.repository_id()]
-      ids.concat(@resolved_bases.first().truncatable_ids()) if self.has_concrete_base?() && self.is_truncatable?()
+      ids = [self.repository_id]
+      ids.concat(@resolved_bases.first.truncatable_ids) if self.has_concrete_base? && self.is_truncatable?
       ids
     end
 
     def add_bases(inherits_)
       inherits_.each do |tc|
         unless tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::TemplateParam)
-          if not (tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::Valuetype))
+          unless (tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::Valuetype))
             raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
           end
+
           rtc = tc.resolved_type
           if rtc.node.has_ancestor?(self)
             raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
           end
-          if not rtc.node.is_defined?
+          unless rtc.node.is_defined?
             raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if self.is_abstract? and not rtc.node.is_abstract?
@@ -1793,7 +1875,8 @@ module IDL::AST
           if @resolved_bases.include?(rtc.node)
             raise "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
           end
-          if (not rtc.node.is_abstract?) and @bases.size > 0
+
+          if (not rtc.node.is_abstract?) and !@bases.empty?
             raise "concrete basevalue #{tc.node.typename} #{tc.node.scoped_lm_name} MUST " +
                   "be first and only non-abstract in inheritance list for #{typename} #{scoped_lm_name}"
           end
@@ -1806,17 +1889,19 @@ module IDL::AST
     def add_interfaces(iflist_)
       iflist_.each do |if_|
         unless if_.is_a?(IDL::Type::ScopedName) && if_.is_node?(IDL::AST::TemplateParam)
-          if not (if_.is_a?(IDL::Type::ScopedName) && if_.is_node?(IDL::AST::Interface))
+          unless (if_.is_a?(IDL::Type::ScopedName) && if_.is_node?(IDL::AST::Interface))
             raise "invalid support identifier for #{typename} #{scoped_lm_name}: #{if_.typename}"
           end
+
           rif_ = if_.resolved_type
           ### @@TODO@@ further validation
-          if (not rif_.node.is_abstract?) and @interfaces.size > 0
+          if (not rif_.node.is_abstract?) and !@interfaces.empty?
             raise "concrete interface '#{rif_.node.scoped_lm_name}' inheritance not allowed for #{typename} #{scoped_lm_name}. Valuetypes can only inherit (support) a single concrete interface."
           end
           if (not rif_.node.is_abstract?) && (not is_interface_compatible?(rif_.node))
             raise "#{typename} #{scoped_lm_name} cannot support concrete interface #{rif_.node.scoped_lm_name} because it does not derive from inherited concrete interfaces"
           end
+
           @resolved_interfaces << rif_.node
         end
         @interfaces << if_.node
@@ -1839,10 +1924,11 @@ module IDL::AST
       if self.is_abstract? && [IDL::AST::StateMember, IDL::AST::Initializer].include?(_type)
         raise "cannot define statemember #{_name} on abstract #{typename} #{scoped_lm_name}"
       end
+
       super(_type, _name, *args)
     end
 
-    def walk_members(&block)
+    def walk_members
       @children.each { |c| yield(c) unless c.is_a?(IDL::AST::StateMember) or
                                            c.is_a?(IDL::AST::Operation) or
                                            c.is_a?(IDL::AST::Attribute) or
@@ -1876,6 +1962,7 @@ module IDL::AST
           if node.is_defined?
             raise "#{node.typename} \"#{node.name}\" is already defined."
           end
+
           node.annotations.concat(params[:annotations])
 
           _new_node = node.class.new(node.name, self, params)
@@ -1910,7 +1997,7 @@ module IDL::AST
 
   protected
 
-    def walk_members_for_copy(&block)
+    def walk_members_for_copy
       @children.each { |c| yield(c) }
     end
 
@@ -1942,6 +2029,7 @@ module IDL::AST
 
   class StateMember < Leaf
     attr_reader :idltype, :visibility
+
     def initialize(_name, _enclosure, params)
       @is_recursive = false
       @has_incomplete_type = false
@@ -1950,8 +2038,9 @@ module IDL::AST
       @visibility = (params[:visibility] == :public ? :public : :private)
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
         raise "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+
         ## check for use of incomplete types
-        if !@idltype.is_complete?
+        unless @idltype.is_complete?
           ## verify type is used in sequence
           if @idltype.resolved_type.is_a?(IDL::Type::Sequence)
             ## find the (non-sequence) elementtype
@@ -1965,7 +2054,7 @@ module IDL::AST
             if mtype.is_a? IDL::Type::ScopedName
               case mtype.resolved_type
               when IDL::Type::Struct, IDL::Type::Union, IDL::Type::Valuetype
-                if !mtype.node.is_defined?
+                unless mtype.node.is_defined?
                   ## check if incomplete struct/union/valuetype is contained within definition of self
                   enc = _enclosure
                   while enc.is_a?(IDL::AST::Struct) || enc.is_a?(IDL::AST::Union) || enc.is_a?(IDL::AST::Valuetype)
@@ -2024,8 +2113,8 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(instantiation_context),
-        :visibility => self.visibility
+        type: @idltype.instantiate(instantiation_context),
+        visibility: self.visibility
       }
       super(instantiation_context, _enclosure, _params)
     end
@@ -2049,10 +2138,11 @@ module IDL::AST
 
   class Initializer < Leaf
     attr_reader :raises, :params
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @params = (params[:params] || []).collect do |(ptype, pname)|
-        IDL::AST::Parameter.new(pname, self, {:attribute => :in, :type => ptype})
+        IDL::AST::Parameter.new(pname, self, {attribute: :in, type: ptype})
       end
       @raises = []
       self.raises = params[:raises]
@@ -2064,6 +2154,7 @@ module IDL::AST
                   (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
           raise 'Only IDL Exception types allowed in raises declaration.'
         end
+
         @raises << extype
       end
     end
@@ -2080,7 +2171,7 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :raises => self.concrete_raises(instantiation_context)
+        raises: self.concrete_raises(instantiation_context)
       }
       _init = super(instantiation_context, _enclosure, _params)
       _init.set_concrete_parameters(instantiation_context, @params)
@@ -2098,11 +2189,10 @@ module IDL::AST
     def set_concrete_parameters(instantiation_context, parms)
       @params = parms.collect do |parm|
         IDL::AST::Parameter.new(parm.name, self,
-                           { :attribute => :in,
-                             :type => parm.idltype.instantiate(instantiation_context) })
+                           { attribute: :in,
+                             type: parm.idltype.instantiate(instantiation_context) })
       end
     end
-
   end # Initializer
 
   class Finder < Initializer
@@ -2110,6 +2200,7 @@ module IDL::AST
 
   class Const < Leaf
     attr_reader :idltype, :expression, :value
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype = params[:type]
@@ -2117,7 +2208,8 @@ module IDL::AST
       @value = nil
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
         raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
-        raise "Incomplete type #{@idltype.typename} not allowed here!" if !@idltype.is_complete?
+        raise "Incomplete type #{@idltype.typename} not allowed here!" unless @idltype.is_complete?
+
         unless @expression.is_a?(IDL::Expression::ScopedName) && @expression.is_node?(IDL::AST::TemplateParam)
           @value = @idltype.narrow(@expression.value)
         end
@@ -2141,21 +2233,24 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(instantiation_context),
-        :expression => @expression.instantiate(instantiation_context)
+        type: @idltype.instantiate(instantiation_context),
+        expression: @expression.instantiate(instantiation_context)
       }
       super(instantiation_context, _enclosure, _params)
     end
   end # Const
 
   class Parameter < Leaf
-    IN, OUT, INOUT = 0, 1, 2
+    IN = 0
+    OUT = 1
+    INOUT = 2
     ATTRIBUTE_MAP = {
-      :in => IN,
-      :out => OUT,
-      :inout => INOUT
+      in: IN,
+      out: OUT,
+      inout: INOUT
     }
     attr_reader :idltype
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype = params[:type]
@@ -2163,15 +2258,18 @@ module IDL::AST
       unless ATTRIBUTE_MAP.has_key?(@attribute)
         raise "invalid attribute for parameter: #{params[:attribute]}"
       end
+
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
         raise "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+        raise "Exception #{@idltype.typename} is not allowed in an argument of an operation!" if @idltype.is_node?(IDL::AST::Exception)
+
         if @idltype.is_local?
           if _enclosure.enclosure.is_a?(IDL::AST::Interface) && !_enclosure.enclosure.is_local?
             raise "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
-        if !@idltype.is_complete?
+        unless @idltype.is_complete?
           if _enclosure.enclosure.is_a?(IDL::AST::Interface)
             raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
@@ -2196,8 +2294,8 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(instantiation_context),
-        :attribute => @attribute
+        type: @idltype.instantiate(instantiation_context),
+        attribute: @attribute
       }
       super(instantiation_context, _enclosure, _params)
     end
@@ -2218,13 +2316,14 @@ module IDL::AST
       @context = nil
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
         raise "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+
         if @idltype.is_local?
           if _enclosure.is_a?(IDL::AST::Interface) && !_enclosure.is_local?
             raise "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
-        if !@idltype.is_complete?
+        unless @idltype.is_complete?
           if _enclosure.is_a?(IDL::AST::Interface)
             raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
@@ -2249,8 +2348,8 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(instantiation_context),
-        :oneway => @oneway,
+        type: @idltype.instantiate(instantiation_context),
+        oneway: @oneway
       }
       _op = super(instantiation_context, _enclosure, _params)
       _op.raises = self.concrete_raises(instantiation_context)
@@ -2264,6 +2363,7 @@ module IDL::AST
                 (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
           raise 'Only IDL Exception or Native types allowed in raises declaration.'
         end
+
         @raises << extype
       end
     end
@@ -2285,9 +2385,11 @@ module IDL::AST
     def in_params
       @in
     end
+
     def out_params
       @out
     end
+
     def params
       self.children
     end
@@ -2318,8 +2420,8 @@ module IDL::AST
   end # Operation
 
   class Attribute < Leaf
-    attr_reader :idltype, :readonly
-    attr_reader :get_raises, :set_raises
+    attr_reader :idltype, :readonly, :get_raises, :set_raises
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype = params[:type]
@@ -2327,13 +2429,15 @@ module IDL::AST
       @set_raises = []
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
         raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
+        raise "Exception #{@idltype.typename} is not allowed as an attribute!" if @idltype.is_node?(IDL::AST::Exception)
+
         if @idltype.is_local?
           if _enclosure.is_a?(IDL::AST::Interface) && !_enclosure.is_local?
             raise "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
-        if !@idltype.is_complete?
+        unless @idltype.is_complete?
           if _enclosure.is_a?(IDL::AST::Interface)
             raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
@@ -2357,8 +2461,8 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(instantiation_context),
-        :readonly => @readonly
+        type: @idltype.instantiate(instantiation_context),
+        readonly: @readonly
       }
       _att = super(instantiation_context, _enclosure, _params)
       _att.get_raises = self.concrete_get_raises(instantiation_context)
@@ -2387,7 +2491,7 @@ module IDL::AST
     end
 
     def expanded_copy(name_pfx, enc)
-      att = IDL::AST::Attribute.new("#{name_pfx}_#{self.name}", enc, {:type => @idltype, :readonly => @readonly})
+      att = IDL::AST::Attribute.new("#{name_pfx}_#{self.name}", enc, {type: @idltype, readonly: @readonly})
       att.get_raises = @get_raises unless @get_raises.empty?
       att.set_raises = @set_raises unless @set_raises.empty?
       att
@@ -2411,42 +2515,81 @@ module IDL::AST
   class Struct < Node
     DEFINABLE = [IDL::AST::Member, IDL::AST::Struct, IDL::AST::Union, IDL::AST::Enum, IDL::AST::Enumerator]
     attr_reader :idltype
+
     def initialize(_name, _enclosure, params)
       @defined = false
       @recursive = false
       @forward = params[:forward] ? true : false
       super(_name, _enclosure)
       @idltype = IDL::Type::Struct.new(self)
+      @base = set_base(params[:inherits])
+    end
+
+    def set_base(inherits)
+      unless inherits.nil?
+        rtc = inherits.resolved_type
+        unless rtc.node.is_defined?
+         raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{rtc.node.typename} #{rtc.node.scoped_lm_name}"
+        end
+        unless rtc.node.is_a?(IDL::AST::Struct)
+          raise "#{typename} #{scoped_lm_name} cannot inherit from non structure #{rtc.node.typename} #{rtc.node.scoped_lm_name}"
+        end
+        inherits.node
+      end
     end
 
-    def is_defined?; @defined end
-    def defined=(f); @defined = f end
-    def is_forward?; @forward end
-    def is_recursive?; @recursive end
-    def recursive=(f); @recursive = f end
+    def base
+      @base
+    end
 
-    def walk_members(&block)
-      @children.each { |m| yield(m) if not m.is_a? IDL::AST::Member }
+    def is_defined?
+      @defined
+    end
+
+    def defined=(f)
+      @defined = f
+    end
+
+    def is_forward?
+      @forward
+    end
+
+    def is_recursive?
+      @recursive
+    end
+
+    def recursive=(f)
+      @recursive = f
+    end
+
+    def walk_members
+      @children.each { |m| yield(m) unless m.is_a? IDL::AST::Member }
     end
 
     def members
       @children.find_all { |c| c.is_a? IDL::AST::Member }
     end
 
+    def types
+      @children.reject { |c| c.is_a? IDL::AST::Member }
+    end
+
     def is_local?(recurstk = [])
       # not local if forward decl or recursion detected
       return false if is_forward? || recurstk.include?(self)
-      recurstk.push self   # track root node to detect recursion
+
+      recurstk.push self # track root node to detect recursion
       ret = members.any? { |m| m.is_local?(recurstk) }
       recurstk.pop
       ret
     end
 
     def marshal_dump
-      super() << @idltype << @defined << @recursive << @forward
+      super() << @idltype << @defined << @recursive << @forward << @base
     end
 
     def marshal_load(vars)
+      @base = vars.pop
       @forward = vars.pop
       @recursive = vars.pop
       @defined = vars.pop
@@ -2456,7 +2599,7 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :forward => @forward
+        forward: @forward
       }
       _s = super(instantiation_context, _enclosure, _params)
       _s.defined = self.is_defined?
@@ -2465,7 +2608,7 @@ module IDL::AST
 
   protected
 
-    def walk_members_for_copy(&block)
+    def walk_members_for_copy
       @children.each { |c| yield(c) }
     end
   end # Struct
@@ -2480,13 +2623,16 @@ module IDL::AST
 
   class Member < Leaf
     attr_reader :idltype
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
-      @idltype  = params[:type]
+      @idltype = params[:type]
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
         raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
+        raise "Exception #{@idltype.typename} is not allowed as member!" if @idltype.is_node?(IDL::AST::Exception)
+
         ## check for use of incomplete types
-        if !@idltype.is_complete?
+        unless @idltype.is_complete?
           ## verify type is used in sequence
           if @idltype.resolved_type.is_a? IDL::Type::Sequence
             ## find the (non-sequence) elementtype
@@ -2500,7 +2646,7 @@ module IDL::AST
             if mtype.is_a? IDL::Type::ScopedName
               case mtype.resolved_type
               when IDL::Type::Struct, IDL::Type::Union, IDL::Type::Valuetype
-                if !mtype.node.is_defined?
+                unless mtype.node.is_defined?
                   ## check if incomplete struct/union is contained within definition of self
                   enc = _enclosure
                   while enc.is_a?(IDL::AST::Struct) || enc.is_a?(IDL::AST::Union) || enc.is_a?(IDL::AST::Valuetype)
@@ -2538,7 +2684,7 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure, _params = {})
       _params.merge!({
-        :type => @idltype.instantiate(instantiation_context),
+        type: @idltype.instantiate(instantiation_context)
       })
       super(instantiation_context, _enclosure, _params)
     end
@@ -2548,6 +2694,7 @@ module IDL::AST
     DEFINABLE = [IDL::AST::UnionMember, IDL::AST::Struct, IDL::AST::Union, IDL::AST::Enum, IDL::AST::Enumerator]
     attr_reader :idltype
     attr_accessor :switchtype
+
     def initialize(_name, _enclosure, params)
       @defined = false
       @recursive = false
@@ -2561,24 +2708,43 @@ module IDL::AST
       @switchtype = _switchtype
     end
 
-    def is_defined?; @defined; end
-    def defined=(f); @defined = f; end
-    def is_forward?; @forward; end
-    def is_recursive?; @recursive end
-    def recursive=(f); @recursive = f end
+    def is_defined?
+      @defined
+    end
 
-    def walk_members(&block)
-      @children.each { |m| yield(m) if not m.is_a? IDL::AST::UnionMember }
+    def defined=(f)
+      @defined = f
+    end
+
+    def is_forward?
+      @forward
+    end
+
+    def is_recursive?
+      @recursive
+    end
+
+    def recursive=(f)
+      @recursive = f
+    end
+
+    def walk_members
+      @children.each { |m| yield(m) unless m.is_a? IDL::AST::UnionMember }
     end
 
     def members
       @children.find_all { |c| c.is_a? IDL::AST::UnionMember }
     end
 
+    def types
+      @children.reject { |c| c.is_a? IDL::AST::UnionMember }
+    end
+
     def is_local?(recurstk = [])
       # not local if forward decl or recursion detected
       return false if is_forward? || recurstk.include?(self)
-      recurstk.push self   # track root node to detect recursion
+
+      recurstk.push self # track root node to detect recursion
       ret = members.any? { |m| m.is_local?(recurstk) }
       recurstk.pop
       ret
@@ -2590,12 +2756,14 @@ module IDL::AST
 
     def default_label
       swtype = @switchtype.resolved_type
+      return nil if IDL::Type::WChar === swtype # No default label detection for wchar
       lbls = members.collect { |m| m.labels.include?(:default) ? [] : m.labels.collect { |l| l.value } }.flatten
       lbls = lbls.sort unless IDL::Type::Boolean === swtype ## work around bug in Ruby 1.9.2
       def_lbl = swtype.min
       while swtype.in_range?(def_lbl)
         return IDL::Expression::Value.new(@switchtype, def_lbl) unless lbls.include?(def_lbl)
         return nil if def_lbl == swtype.max
+
         def_lbl = swtype.next(def_lbl)
       end
       nil
@@ -2603,6 +2771,7 @@ module IDL::AST
 
     def validate_labels
       return if self.is_template?
+
       labelvals = []
       default_ = false
       members.each { |m|
@@ -2610,14 +2779,16 @@ module IDL::AST
         m.labels.each { |lbl|
           if lbl == :default
             raise "duplicate case label 'default' for #{typename} #{lm_name}" if default_
+
             default_ = true
           else
             # correct type
             lv = @switchtype.resolved_type.narrow(lbl.value)
             # doubles
             if labelvals.include? lv
-              raise "duplicate case label #{lv.to_s} for #{typename} #{lm_name}"
+              raise "duplicate case label #{lv} for #{typename} #{lm_name}"
             end
+
             labelvals << lv
           end
         }
@@ -2645,7 +2816,7 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :forward => @forward
+        forward: @forward
       }
       _u = super(instantiation_context, _enclosure, _params)
       _u.set_switchtype(@switchtype.instantiate(instantiation_context))
@@ -2656,20 +2827,21 @@ module IDL::AST
 
   protected
 
-      def walk_members_for_copy(&block)
+      def walk_members_for_copy
         @children.each { |c| yield(c) }
       end
   end # Union
 
   class UnionMember < Member
     attr_reader :labels
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure, params)
       ## if any of the labels is 'default' forget about the others
       if params[:labels].include?(:default)
-        @labels = [ :default ]
+        @labels = [:default]
       else
-        @labels  = params[:labels]
+        @labels = params[:labels]
       end
     end
 
@@ -2684,26 +2856,32 @@ module IDL::AST
 
     def instantiate(instantiation_context, _enclosure)
       _params = {
-        :labels => @labels.collect { |l| l == :default ? l : l.instantiate(instantiation_context) },
+        labels: @labels.collect { |l| l == :default ? l : l.instantiate(instantiation_context) }
       }
       super(instantiation_context, _enclosure, _params)
     end
   end # UnionMember
 
   class Enum < Leaf
-    attr_reader :idltype
-    def initialize(_name, _enclosure, params)
-      super(_name, _enclosure)
+    attr_reader :idltype, :bitbound, :bitbound_bits
+
+    def initialize(_name, enclosure, params)
+      super(_name, enclosure)
       @enums = []
       @idltype = IDL::Type::Enum.new(self)
+      @bitbound = IDL::Type::ULong.new
+      @bitbound_bits = 32
+      annotations.concat(params[:annotations])
     end
 
     def marshal_dump
-      super() << @idltype << @enums
+      super() << @idltype << @bitbound << @bitbound_bits << @enums
     end
 
     def marshal_load(vars)
       @enums = vars.pop
+      @bitbound = vars.pop
+      @bitbound_bits = vars.pop
       @idltype = vars.pop
       super(vars)
     end
@@ -2716,14 +2894,27 @@ module IDL::AST
       @enums << n
     end
 
+    def determine_bitbound
+      bitbound = annotations[:bit_bound].first
+      unless bitbound.nil?
+        @bitbound_bits = bitbound.fields[:value]
+        raise "Missing number of bits for bit_bound annotation for #{name}" if @bitbound_bits.nil?
+        raise "Illegal negative bit_bound #{bits} value for #{name}" if @bitbound_bits.negative?
+        raise "Illegal zero bit_bound value for #{name}, not #{bits}" if @bitbound_bits.zero?
+        raise "Bitbound for #{name} must be <= 32" unless @bitbound_bits <= 32
+      end
+      @bitbound = IDL::Type::UTinyShort.new if @bitbound_bits.between?(1,8)
+      @bitbound = IDL::Type::UShort.new if @bitbound_bits.between?(9,16)
+    end
+
     def instantiate(instantiation_context, _enclosure)
       super(instantiation_context, _enclosure, {})
     end
-
   end # Enum
 
   class Enumerator < Leaf
     attr_reader :idltype, :enum, :value
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype = IDL::Type::ULong.new
@@ -2747,15 +2938,241 @@ module IDL::AST
       # find already instantiated Enum parent
       _enum = _enclosure.resolve(@enum.name)
       raise "Unable to resolve instantiated Enum scope for enumerator #{@enum.name}::#{name} instantiation" unless _enum
-      super(instantiation_context, _enclosure, { :enum => _enum, :value => @value })
+
+      super(instantiation_context, _enclosure, { enum: _enum, value: @value })
     end
   end # Enumerator
 
-  class Typedef < Leaf
+  class BitMask < Node
+    DEFINABLE = [IDL::AST::BitValue]
+    attr_reader :idltype, :bitbound, :bitbound_bits
+
+    def initialize(name, enclosure, params)
+      super(name, enclosure)
+      @bitvalues = []
+      @idltype = IDL::Type::BitMask.new(self)
+      annotations.concat(params[:annotations])
+    end
+
+    def marshal_dump
+      super() << @idltype << @bitbound << @bitbound_bits << @bitvalues
+    end
+
+    def marshal_load(vars)
+      @bitvalues = vars.pop
+      @bitbound_bits = vars.pop
+      @bitbound = vars.pop
+      @idltype = vars.pop
+      super(vars)
+    end
+
+    def bitvalues
+      @bitvalues
+    end
+
+    def add_bitvalue(n)
+      @bitvalues << n
+    end
+
+    def determine_bitbound
+      bitbound = annotations[:bit_bound].first
+      @bitbound_bits = @bitvalues.size
+      unless bitbound.nil?
+        @bitbound_bits = bitbound.fields[:value]
+        raise "Missing number of bits for bit_bound annotation for #{name}" if @bitbound_bits.nil?
+        raise "Illegal negative bit_bound #{bits} value for #{name}" if @bitbound_bits.negative?
+        raise "Illegal zero bit_bound value for #{name}, not #{bits}" if @bitbound_bits.zero?
+        raise "Bitbound for #{name} must be <= 64" unless @bitbound_bits <= 64
+      end
+      @bitbound = IDL::Type::UTinyShort.new if @bitbound_bits.between?(1,8)
+      @bitbound = IDL::Type::UShort.new if @bitbound_bits.between?(9,16)
+      @bitbound = IDL::Type::ULong.new if @bitbound_bits.between?(17,32)
+      @bitbound = IDL::Type::ULongLong.new if @bitbound_bits.between?(33,64)
+    end
+
+    def instantiate(instantiation_context, _enclosure)
+      super(instantiation_context, _enclosure, {})
+    end
+  end # BitMask
+
+  class BitValue < Leaf
+    attr_reader :idltype, :bitmask, :position
+
+    def initialize(name, enclosure, params)
+      super(name, enclosure)
+      @idltype = IDL::Type::ULong.new
+      @bitmask = params[:bitmask]
+      @position = params[:position]
+      annotations.concat(params[:annotations])
+      position_annotation = annotations[:position].first
+      unless position_annotation.nil?
+        @position = position_annotation.fields[:value]
+      end
+      @bitmask.add_bitvalue(self)
+    end
+
+    def marshal_dump
+      super() << @idltype << @bitmask << @position
+    end
+
+    def marshal_load(vars)
+      @position = vars.pop
+      @bitmask = vars.pop
+      @idltype = vars.pop
+      super(vars)
+    end
+
+    def instantiate(instantiation_context, _enclosure)
+      # find already instantiated BitMask parent
+      _bitmask = _enclosure.resolve(@bitmask.name)
+      raise "Unable to resolve instantiated BitMask scope for bitvalue #{@bitmask.name}::#{name} instantiation" unless _bitmask
+
+      super(instantiation_context, _enclosure, { bitmask: _bitmask, position: @position })
+    end
+  end # BitValue
+
+  class BitSet < Node
+    DEFINABLE = [IDL::AST::BitField]
     attr_reader :idltype
+
+    def initialize(_name, enclosure, params)
+      super(_name, enclosure)
+      @bitfields = []
+      @bitset_bits = 0
+      @idltype = IDL::Type::BitSet.new(self)
+      @base = set_base(params[:inherits])
+    end
+
+    def set_base(inherits)
+      unless inherits.nil?
+        rtc = inherits.resolved_type
+        unless rtc.node.is_a?(IDL::AST::BitSet)
+          raise "#{typename} #{scoped_lm_name} cannot inherit from non bitset #{rtc.node.typename} #{rtc.node.scoped_lm_name}"
+        end
+        inherits.node
+      end
+    end
+
+    def base
+      @base
+    end
+
+    # Override from Node base to handle anonymous bitfields
+    def define(_type, _name, params = {})
+      unless is_definable?(_type)
+        raise "#{_type} is not definable in #{self.typename}."
+      end
+
+      # All IDL definables have a name except a bitfield, that has an optional name and can
+      # be anonymous
+      node = search_self(_name) unless _name.nil?
+      if node.nil?
+        node = _type.new(_name, self, params)
+        node.annotations.concat(params[:annotations])
+        node.prefix = @prefix
+        introduce(node) unless _name.nil? # If there is no name don't introduce it in our scope
+        @children << node
+      else
+        if _type != node.class
+          raise "#{_name} is already defined as a type of #{node.typename}"
+        end
+
+        node = redefine(node, params)
+      end
+      node
+    end
+
+    def marshal_dump
+      super() << @idltype << @bitset_bits << @bitfields << @base
+    end
+
+    def marshal_load(vars)
+      @base = vars.pop
+      @bitfields = vars.pop
+      @bitset_bits = vars.pop
+      @idltype = vars.pop
+      super(vars)
+    end
+
+    # Total number of bits in this bitset including the optional base
+    def bitset_bits
+      base.nil? ? @bitset_bits : @bitset_bits + base.bitset_bits
+    end
+
+    # Underlying type which is large enough to contain the full bitset
+    # including its base
+    def underlying_type
+      return IDL::Type::UTinyShort.new if bitset_bits.between?(1,8)
+      return IDL::Type::UShort.new if bitset_bits.between?(9,16)
+      return IDL::Type::ULong.new if bitset_bits.between?(17,32)
+      return IDL::Type::ULongLong.new if bitset_bits.between?(33,64)
+    end
+
+    def bitfields
+      @bitfields
+    end
+
+    def add_bitfield(n)
+      @bitfields << n
+      @bitset_bits += n.bits
+      raise "Bitset size #{bitset_bits} must be between 1 and 64" unless bitset_bits.between?(1, 64)
+    end
+
+    def instantiate(instantiation_context, _enclosure)
+      super(instantiation_context, _enclosure, {})
+    end
+  end # BitSet
+
+  class BitField < Leaf
+    attr_reader :idltype, :bitset, :bits
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
-      @idltype  = params[:type]
+      @idltype = params[:idltype]
+      @bitset = params[:bitset]
+      @bits = params[:bits]
+
+      raise "Amount of bits for bitfield #{_name} must <= 64, not #{bits}" if bits > 64
+
+      # When no IDL type has been specified for the bitfield in IDL we need to determine
+      # the underlying type based on the number of bits
+      if @idltype.nil?
+        @idltype = IDL::Type::Boolean.new if bits == 1
+        @idltype = IDL::Type::TinyShort.new if bits.between?(2,8)
+        @idltype = IDL::Type::Short.new if bits.between?(9,16)
+        @idltype = IDL::Type::Long.new if bits.between?(17,32)
+        @idltype = IDL::Type::LongLong.new if bits.between?(33,64)
+      end
+      @bitset.add_bitfield(self)
+    end
+
+    def marshal_dump
+      super() << @idltype << @bits << @bitset << @value
+    end
+
+    def marshal_load(vars)
+      @value = vars.pop
+      @bitset = vars.pop
+      @bits = vars.pop
+      @idltype = vars.pop
+      super(vars)
+    end
+
+    def instantiate(instantiation_context, _enclosure)
+      # find already instantiated BitSet parent
+      _bitmask = _enclosure.resolve(@bitset.name)
+      raise "Unable to resolve instantiated BitSet scope for bitfield #{@bitset.name}::#{name} instantiation" unless _bitset
+
+      super(instantiation_context, _enclosure, { bitset: _bitset, bits: @bits })
+    end
+  end # BitField
+
+  class Typedef < Leaf
+    attr_reader :idltype
+
+    def initialize(_name, enclosure, params)
+      super(_name, enclosure)
+      @idltype = params[:type]
     end
 
     def is_local?(recurstk = [])
@@ -2772,7 +3189,7 @@ module IDL::AST
     end
 
     def instantiate(instantiation_context, _enclosure)
-      super(instantiation_context, _enclosure, { :type => @idltype.instantiate(instantiation_context) })
+      super(instantiation_context, _enclosure, { type: @idltype.instantiate(instantiation_context) })
     end
   end # Typedef
 end