ridl 2.5.6 → 2.8.1

data/lib/ridl/expression.rb

@@ -8,7 +8,6 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 require 'ridl/node'
 
@@ -22,7 +21,7 @@ module IDL
       false
     end
 
-    def instantiate(_context)
+    def instantiate(_)
       self
     end
 
@@ -38,8 +37,7 @@ module IDL
       def initialize(node)
         if $DEBUG
           unless IDL::AST::Const === node || (IDL::AST::TemplateParam === node && node.idltype.is_a?(IDL::Type::Const))
-            raise RuntimeError,
-              "#{node.scoped_name} must be constant: #{node.class.name}."
+            raise "#{node.scoped_name} must be constant: #{node.class.name}."
           end
         end
         @node = node
@@ -49,9 +47,9 @@ module IDL
       def is_template?
         @node.is_template?
       end
-      def instantiate(_context)
+      def instantiate(instantiation_context)
         if self.is_template?
-          cp = IDL::AST::TemplateParam.concrete_param(_context, @node)
+          cp = IDL::AST::TemplateParam.concrete_param(instantiation_context, @node)
           cp.is_a?(Expression) ? cp : ScopedName.new(cp)
         else
           self
@@ -70,8 +68,7 @@ module IDL
       def initialize(node)
         if $DEBUG
           if not IDL::AST::Enumerator === node
-            raise RuntimeError,
-              "#{node.scoped_name} must be enumerator: #{node.class.name}."
+            raise "#{node.scoped_name} must be enumerator: #{node.class.name}."
           end
         end
         @node = node
@@ -88,9 +85,8 @@ module IDL
         n = self.class::NUMBER_OF_OPERANDS
 
         if _operands.size != n
-          raise RuntimeError,
-            format("%s must receive %d operand%s.",
-            self.typename, n, if (n>1) then "s" else "" end)
+          raise format("%s must receive %d operand%s.",
+            self.typename, n, if (n > 1) then "s" else "" end)
         end
 
         unless _operands.any? { |o| o.is_template? }
@@ -108,15 +104,14 @@ module IDL
         @operands.any? { |o| o.is_template? }
       end
 
-      def instantiate(_context)
-        self.is_template? ? self.class.new(*@operands.collect { |o| o.instantiate(_context) }) : self
+      def instantiate(instantiation_context)
+        self.is_template? ? self.class.new(*@operands.collect { |o| o.instantiate(instantiation_context) }) : self
       end
 
       def Operation.suite_type(*types)
         types.each do |t|
           if not self::Applicable.include? t.class
-            raise RuntimeError,
-              "#{self.name} cannot be applicable for #{t.typename}"
+            raise "#{self.name} cannot be applicable for #{t.typename}"
           end
         end
 
@@ -174,8 +169,7 @@ module IDL
 
           t = IDL::Type::Boolean
           if (t1 == t && t2 != t) or (t1 != t && t2 == t)
-            raise RuntimeError,
-              "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
+            raise "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
           end
         end
       end
@@ -190,10 +184,9 @@ module IDL
           superclass.checktype(*types)
 
           # it's expected that Double, LongDouble is a Float.
-          s1,s2 = IDL::Type::Float, IDL::Type::Fixed
+          s1, s2 = IDL::Type::Float, IDL::Type::Fixed
           if (t1 === s1 && t2 === s2) or (t1 === s2 && t2 === s1)
-            raise RuntimeError,
-              "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
+            raise "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
           end
         end
       end
@@ -217,7 +210,7 @@ module IDL
         Applicable = Integer2::Applicable
         def calculate(op)
           if @idltype.is_unsigned?()
-            (2**@idltype.bits-1)-op
+            (2**@idltype.bits - 1) - op
           else
             ~op
           end
@@ -225,51 +218,50 @@ module IDL
       end
 
       class Or < Boolean2
-        def calculate(lop,rop); lop | rop; end
+        def calculate(lop, rop); lop | rop; end
       end
       class And < Boolean2
-        def calculate(lop,rop); lop & rop; end
+        def calculate(lop, rop); lop & rop; end
       end
       class Xor < Boolean2
-        def calculate(lop,rop); lop ^ rop; end
+        def calculate(lop, rop); lop ^ rop; end
       end
 
       class Shift < Integer2
       protected
         def check_rop(rop)
           if not (0...64) === rop
-            raise RuntimeError,
-              "right operand for shift must be in the range 0 <= right operand < 64: #{rop}."
+            raise "right operand for shift must be in the range 0 <= right operand < 64: #{rop}."
           end
         end
       end
       class LShift < Shift
-        def calculate(lop,rop)
+        def calculate(lop, rop)
           check_rop(rop)
           lop << rop
         end
       end
       class RShift < Shift
-        def calculate(lop,rop)
+        def calculate(lop, rop)
           check_rop(rop)
           lop >> rop
         end
       end
 
       class Add < Float2
-        def calculate(lop,rop); lop + rop; end
+        def calculate(lop, rop); lop + rop; end
       end
       class Minus < Float2
-        def calculate(lop,rop); lop - rop; end
+        def calculate(lop, rop); lop - rop; end
       end
       class Mult < Float2
-        def calculate(lop,rop); lop * rop; end
+        def calculate(lop, rop); lop * rop; end
       end
       class Div < Float2
-        def calculate(lop,rop); lop / rop; end
+        def calculate(lop, rop); lop / rop; end
       end
       class Mod < Integer2
-        def calculate(lop,rop); lop % rop; end
+        def calculate(lop, rop); lop % rop; end
       end
     end #of class Operation
   end #of class Expression

data/lib/ridl/genfile.rb

@@ -8,7 +8,6 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 require 'tempfile'
 require 'fileutils'
@@ -68,7 +67,7 @@ module IDL
     class Content
       def initialize(sections = {})
         # copy content map transforming all keys to symbols
-        @sections = sections.inject({}) {|m,(k,v)| m[k.to_sym] = v; m }
+        @sections = sections.inject({}) {|m, (k, v)| m[k.to_sym] = v; m }
       end
 
       def sections
@@ -97,7 +96,7 @@ module IDL
         @path = path
         @fullpath = File.expand_path(path)
         @name = File.basename(path)
-        @ext = File.extname(path).sub(/^\./,'')
+        @ext = File.extname(path).sub(/^\./, '')
       else
         @path = @fullpath = @name = @ext = ''
       end
@@ -110,7 +109,7 @@ module IDL
         :output_file => nil,
         :create_missing_dir => false
       }.merge(opts)
-      if @options[:regenerate] && File.exists?(@fullpath)
+      if @options[:regenerate] && File.exist?(@fullpath)
         parse_regeneration_content
       else
         @content = Content.new
@@ -160,7 +159,7 @@ module IDL
         fgen = @fout
         @fout = nil
         fgen.close(false) # close but do NOT unlink
-        if File.exists?(@fullpath)
+        if File.exist?(@fullpath)
           # create temporary backup
           ftmp = Tempfile.new(@name)
           ftmp_name = ftmp.path.dup
@@ -225,22 +224,22 @@ module IDL
           if regen_marker_re =~ line
             case $1
             when 'BEGIN'
-              raise RuntimeError, "ERROR: Found unterminated regeneration section starting at #{@path}:#{in_section.last}." if in_section
+              raise "ERROR: Found unterminated regeneration section starting at #{@path}:#{in_section.last}." if in_section
               in_section = [$2, linenr]
               section = []
             when 'END'
-              raise RuntimeError, "ERROR: Found unmatched regeneration end at #{@path}:#{linenr}." unless in_section && ($2 == in_section.first)
+              raise "ERROR: Found unmatched regeneration end at #{@path}:#{linenr}." unless in_section && ($2 == in_section.first)
               sections[$2] = section
               in_section = nil
               section = []
             when 'HEADER_END'
-              raise RuntimeError, "ERROR: Found illegal header end marker at #{@path}:#{linenr}." unless _keep_header && in_section &&
+              raise "ERROR: Found illegal header end marker at #{@path}:#{linenr}." unless _keep_header && in_section &&
                                                                                                          ('HEADER' == in_section.first ) && (0 == in_section.last)
               sections[$2] = section
               in_section = nil
               section = []
             else
-              raise RuntimeError, "ERROR: Found invalid regeneration marker at #{@path}:#{linenr}."
+              raise "ERROR: Found invalid regeneration marker at #{@path}:#{linenr}."
             end
           elsif in_section
             section << line

data/lib/ridl/node.rb

@@ -8,7 +8,6 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 module IDL::AST
 
@@ -20,7 +19,7 @@ module IDL::AST
       @id = id.to_sym
       # copy field map transforming all keys to symbols and
       # detecting nested annotation objects
-      @fields = fields.inject({}) do |m,(k,v)|
+      @fields = fields.inject({}) do |m, (k, v)|
           m[k.to_sym] = case v
               when Array
                 v.collect { |ve| Hash === ve ? Annotation.new(*ve.to_a.first) : ve }
@@ -49,9 +48,9 @@ module IDL::AST
   end
 
   class Annotations
-    def initialize(stack = [], index = {})
-      @index = index
-      @stack = stack
+    def initialize
+      @index = {}
+      @stack = []
     end
 
     def empty?
@@ -75,23 +74,13 @@ module IDL::AST
       self[annid].each(&block)
     end
 
-    def clear
-      @index.clear
-      @stack.clear
-    end
-
     def concat(anns)
-      (anns || []).each {|_ann| self << _ann }
-    end
-
-    def dup
-      self.class.new(@stack.dup, @index.dup)
+      anns.each {|_ann| self << _ann } if anns
     end
   end
 
   class Leaf
     attr_reader :name, :intern
-    attr_reader :lm_name
     attr_accessor :enclosure
     attr_reader :scopes
     attr_reader :prefix
@@ -105,26 +94,26 @@ module IDL::AST
       _name ||= ''
       _name = IDL::Scanner::Identifier.new(_name, _name) unless IDL::Scanner::Identifier === _name
       @name = _name
-      @lm_name = self.class.mk_name(_name.checked_name, _enclosure.nil? ? false : _enclosure.scopes.size>0).freeze
+      @lm_name = nil
       @intern = _name.rjust(1).downcase.intern
       @enclosure = _enclosure
-      @scopes = if @enclosure.nil? then [] else (@enclosure.scopes.dup << self) end
+      @scopes = if @enclosure then (@enclosure.scopes.dup << self) else [] end
       @prefix = ''
       @repo_id = nil
       @repo_ver = nil
       @annotations = Annotations.new
     end
 
-    def unescaped_name
-      @name.unescaped_name
+    def lm_name
+      @lm_name ||= @name.checked_name.dup
     end
 
-    def parsed_name_scope
-      (@enclosure ? @enclosure.parsed_name_scope : '') + '::' + @name
+    def lm_scopes
+      @lm_scopes ||= if @enclosure then (@enclosure.lm_scopes.dup << lm_name) else [] end
     end
 
-    def lm_name_for_scope
-      lm_name
+    def unescaped_name
+      @name.unescaped_name
     end
 
     def scoped_name
@@ -132,52 +121,47 @@ module IDL::AST
     end
 
     def scoped_lm_name
-      @scoped_lm_name ||= @scopes.collect{|s| s.lm_name_for_scope }.join('::').freeze
+      @scoped_lm_name ||= lm_scopes.join("::").freeze
     end
 
     def marshal_dump
-      [@name, @lm_name, @intern, @enclosure, @scopes, @prefix, @repo_id, @repo_ver, @annotations]
+      [@name, lm_name, @intern, @enclosure, @scopes, @prefix, @repo_id, @repo_ver, @annotations]
     end
 
     def marshal_load(vars)
       @name, @lm_name, @intern, @enclosure, @scopes, @prefix, @repo_id, @repo_ver, @annotations = vars
       @scoped_name = nil
       @scoped_lm_name = nil
-    end
-
-    def repo_scopes
-      @repo_scopes ||= (@enclosure.nil? ? [] : (@enclosure.repo_scopes.dup << self))
+      @lm_scopes = nil
     end
 
     def is_template?
       @enclosure && @enclosure.is_template?
     end
 
-    def instantiate(_context, _enclosure, _params = {})
-      (_context[self] = self.class.new(self.name, _enclosure, _params)).copy_from(self, _context)
+    def instantiate(instantiation_context, _enclosure, _params = {})
+      (instantiation_context[self] = self.class.new(self.name, _enclosure, _params)).copy_from(self, instantiation_context)
     end
 
     def set_repo_id(id)
       if @repo_id
         if id != @repo_id
-          raise RuntimeError,
-            "#{self.scoped_name} already has a different repository ID assigned: #{@repo_id}"
+          raise "#{self.scoped_name} already has a different repository ID assigned: #{@repo_id}"
         end
       end
       id_arr = id.split(':')
       if @repo_ver
         if id_arr.first != 'IDL' or id_arr.last != @repo_ver
-          raise RuntimeError,
-            "supplied repository ID (#{id}) does not match previously assigned repository version for #{self.scoped_name} = #{@repo_ver}"
+          raise "supplied repository ID (#{id}) does not match previously assigned repository version for #{self.scoped_name} = #{@repo_ver}"
         end
       end
       # check validity of IDL format repo IDs
       if id_arr.first == 'IDL'
         id_arr.shift
         id_str = id_arr.shift.to_s
-        raise RuntimeError, 'ID identifiers should not start or end with \'/\'' if id_str[0,1]=='/' or id_str[-1, 1]=='/'
-        raise RuntimeError, "ID identifiers should not start with one of '#{REPO_ID_XCHARS.join("', '")}'" if REPO_ID_XCHARS.include?(id_str[0,1])
-        raise RuntimeError, 'Invalid ID! Only a..z, A..Z, 0..9, \'.\', \'-\', \'_\' or \'\/\' allowed for identifiers' unless REPO_ID_RE =~ id_str
+        raise 'ID identifiers should not start or end with \'/\'' if id_str[0, 1] == '/' or id_str[-1, 1] == '/'
+        raise "ID identifiers should not start with one of '#{REPO_ID_XCHARS.join("', '")}'" if REPO_ID_XCHARS.include?(id_str[0, 1])
+        raise 'Invalid ID! Only a..z, A..Z, 0..9, \'.\', \'-\', \'_\' or \'\/\' allowed for identifiers' unless REPO_ID_RE =~ id_str
       end
       @repo_id = id
     end
@@ -186,15 +170,13 @@ module IDL::AST
       ver = "#{ma}.#{mi}"
       if @repo_ver
         if ver != @repo_ver
-          raise RuntimeError,
-            "#{self.scoped_name} already has a repository version assigned: #{@repo_ver}"
+          raise "#{self.scoped_name} already has a repository version assigned: #{@repo_ver}"
         end
       end
       if @repo_id
         l = @repo_id.split(':')
         if l.last != ver
-          raise RuntimeError,
-            "supplied repository version (#{ver}) does not match previously assigned repository ID for #{self.scoped_name}: #{@repo_id}"
+          raise "supplied repository version (#{ver}) does not match previously assigned repository ID for #{self.scoped_name}: #{@repo_id}"
         end
       end
       @repo_ver = ver
@@ -202,34 +184,30 @@ module IDL::AST
 
     def prefix=(pfx)
       unless pfx.to_s.empty?
-        raise RuntimeError, 'ID prefix should not start or end with \'/\'' if pfx[0,1]=='/' or pfx[-1, 1]=='/'
-        raise RuntimeError, "ID prefix should not start with one of '#{REPO_ID_XCHARS.join("', '")}'" if REPO_ID_XCHARS.include?(pfx[0,1])
-        raise RuntimeError, 'Invalid ID prefix! Only a..z, A..Z, 0..9, \'.\', \'-\', \'_\' or \'\/\' allowed' unless REPO_ID_RE =~ pfx
+        raise 'ID prefix should not start or end with \'/\'' if pfx[0, 1] == '/' or pfx[-1, 1] == '/'
+        raise "ID prefix should not start with one of '#{REPO_ID_XCHARS.join("', '")}'" if REPO_ID_XCHARS.include?(pfx[0, 1])
+        raise 'Invalid ID prefix! Only a..z, A..Z, 0..9, \'.\', \'-\', \'_\' or \'\/\' allowed' unless REPO_ID_RE =~ pfx
       end
-      self._set_prefix(pfx)
+      self.set_prefix(pfx)
     end
 
     def replace_prefix(pfx)
       self.prefix = pfx
     end
 
-    def _set_prefix(pfx)
-      @prefix = pfx.to_s
-    end
-
     def repository_id
       if @repo_id.nil?
         @repo_ver = "1.0" unless @repo_ver
         format("IDL:%s%s:%s",
-                if @prefix.empty? then "" else @prefix+"/" end,
-                self.repo_scopes.collect{|s| s.name}.join("/"),
+                if @prefix.empty? then "" else @prefix + "/" end,
+                self.scopes.collect{|s| s.name}.join("/"),
                 @repo_ver)
       else
         @repo_id
       end
     end
 
-    def has_annotations?()
+    def has_annotations?
       !@annotations.empty?
     end
 
@@ -242,11 +220,16 @@ module IDL::AST
     end
 
   protected
-    def copy_from(_template, _context)
-      @prefix = _template.instance_variable_get(:@prefix)
-      @repo_id = _template.instance_variable_get(:@repo_id)
-      @repo_ver = _template.instance_variable_get(:@repo_ver)
-      @annotations = _template.instance_variable_get(:@annotations)
+
+    def set_prefix(pfx)
+      @prefix = pfx.to_s
+    end
+
+    def copy_from(template, _)
+      @prefix = template.instance_variable_get(:@prefix)
+      @repo_id = template.instance_variable_get(:@repo_id)
+      @repo_ver = template.instance_variable_get(:@repo_ver)
+      @annotations = template.instance_variable_get(:@annotations)
       self
     end
   end # Leaf
@@ -271,8 +254,7 @@ module IDL::AST
 
     def introduce(node)
       n = (@introduced[node.intern] ||= node)
-      raise RuntimeError,
-        "#{node.name} is already introduced as a #{n.scoped_name} of #{n.typename}." if n != node
+      raise "#{node.name} is already introduced as a #{n.scoped_name} of #{n.typename}." if n != node
     end
 
     def undo_introduction(node)
@@ -280,7 +262,7 @@ module IDL::AST
     end
 
     def redefine(node, params)
-      raise RuntimeError, "\"#{node.name}\" is already defined."
+      raise "\"#{node.name}\" is already defined."
     end
 
     def is_definable?(_type)
@@ -291,8 +273,7 @@ module IDL::AST
 
     def define(_type, _name, params = Hash.new)
       if not is_definable?(_type)
-        raise RuntimeError,
-          "#{_type.to_s} is not definable in #{self.typename}."
+        raise "#{_type.to_s} is not definable in #{self.typename}."
       end
       node = search_self(_name)
       if node.nil?
@@ -303,8 +284,7 @@ module IDL::AST
         @children << node
       else
         if _type != node.class
-          raise RuntimeError,
-            "#{_name} is already defined as a type of #{node.typename}"
+          raise "#{_name} is already defined as a type of #{node.typename}"
         end
         node = redefine(node, params)
       end
@@ -343,7 +323,7 @@ module IDL::AST
       key = _name.downcase.intern
       node = @introduced[key]
       if not node.nil? and node.name != _name
-        raise RuntimeError, "\"#{_name}\" clashed with \"#{node.name}\"."
+        raise "\"#{_name}\" clashed with \"#{node.name}\"."
       end
       node
     end
@@ -360,10 +340,10 @@ module IDL::AST
       self.walk_members(&block)
     end
 
-    def copy_from(_template, _context)
+    def copy_from(_template, instantiation_context)
       super
       _template.__send__(:walk_members_for_copy) do |child|
-        _child_copy = child.instantiate(_context, self)
+        _child_copy = child.instantiate(instantiation_context, self)
         @children << _child_copy
         # introduce unless already introduced (happens with module chains)
         @introduced[_child_copy.intern] = _child_copy unless @introduced.has_key?(_child_copy.intern)
@@ -405,7 +385,6 @@ module IDL::AST
   class Enumerator < Leaf; end
 
   class Module < Node
-    NAMETYPE = :class
     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,
@@ -416,7 +395,6 @@ module IDL::AST
       super(_name, _enclosure)
       @anchor = params[:anchor]
       @prefix = params[:prefix] || @prefix
-      @not_in_repo_id = params[:not_in_repo_id]
       @template = params[:template]
       @template_params = (params[:template_params] || []).dup
       @next = nil
@@ -457,12 +435,8 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
-      super(_context, _enclosure, {})
-    end
-
-    def repo_scopes
-      @repo_scopes ||= (@enclosure.nil? ? [] : (@not_in_repo_id ? @enclosure.repo_scopes.dup : (@enclosure.repo_scopes.dup << self)))
+    def instantiate(instantiation_context, _enclosure)
+      super(instantiation_context, _enclosure, {})
     end
 
     def redefine(node, params)
@@ -488,12 +462,16 @@ module IDL::AST
         return _next
       when IDL::AST::Interface
         node.annotations.concat(params[:annotations])
-        return node if params[:forward]
-        if node.is_defined?
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+        # in case of a forward declaration in the same module ignore it since a previous declaration already exists
+        if params[:forward]
+          return node if node.enclosure == self
+          # forward declaration in different scope (other module section in same file or other file)
+        elsif node.is_defined?
+          # multiple full declarations are illegal
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
         if (node.is_abstract? != params[:abstract]) || (node.is_local? != params[:local]) || (node.is_pseudo? != params[:pseudo])
-          raise RuntimeError, "\"attributes are not the same: \"#{node.name}\"."
+          raise "\"attributes are not the same: \"#{node.name}\"."
         end
 
         _intf = IDL::AST::Interface.new(node.name, self, params)
@@ -503,19 +481,25 @@ module IDL::AST
         _intf.instance_variable_set(:@repo_id, node.instance_variable_get(:@repo_id))
 
         @children << _intf
-        # replace forward node registration
-        node.enclosure.undo_introduction(node)
-        introduce(_intf)
+
+        # in case of a full declaration undo the preceding forward introduction and
+        # replace by full node
+        # (no need to introduce forward declaration since there is a preceding introduction)
+        unless params[:forward]
+          # replace forward node registration
+          node.enclosure.undo_introduction(node)
+          introduce(_intf)
+        end
 
         return _intf
       when IDL::AST::Valuetype
         node.annotations.concat(params[:annotations])
         return node if params[:forward]
         if node.is_defined?
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
         if (node.is_abstract? != params[:abstract])
-          raise RuntimeError, "\"attributes are not the same: \"#{node.name}\"."
+          raise "\"attributes are not the same: \"#{node.name}\"."
         end
 
         _new_node = node.class.new(node.name, self, params)
@@ -534,7 +518,7 @@ module IDL::AST
         node.annotations.concat(params[:annotations])
         return node if params[:forward]
         if node.is_defined?
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
 
         _new_node = node.class.new(node.name, self, params)
@@ -552,8 +536,7 @@ module IDL::AST
 
         return _new_node
       end
-      raise RuntimeError,
-            "#{node.name} is already introduced as #{node.typename} #{node.scoped_name}."
+      raise "#{node.name} is already introduced as #{node.typename} #{node.scoped_name}."
     end
 
     def undo_introduction(node)
@@ -567,49 +550,52 @@ module IDL::AST
     def replace_prefix(pfx)
       self.prefix = pfx   # handles validation
       if @anchor.nil?
-        self.replace_prefix_(pfx)
+        self.replace_prefix_i(pfx)
       else
-        @anchor.replace_prefix_(pfx)
+        @anchor.replace_prefix_i(pfx)
       end
     end
 
-    def _set_prefix(pfx)
+  protected
+
+    def set_prefix(pfx)
       if @anchor.nil?
-        self._set_prefix_(pfx)
+        self.set_prefix_i(pfx)
       else
-        @anchor._set_prefix_(pfx)
+        @anchor.set_prefix_i(pfx)
       end
     end
 
-  protected
-
     def get_annotations
       @annotations
     end
 
-    def copy_from(_template, _context)
+    def copy_from(_template, instantiation_context)
       super
       if _template.has_anchor?
         # module anchor is first to be copied/instantiated and
-        # should be registered in _context
-        @anchor = IDL::AST::TemplateParam.concrete_param(_context, _template.anchor)
-        # link ourself into module chain
+        # should be registered in instantiation_context
+        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)
       end
       @next = nil # to be sure
       self
     end
 
-    def replace_prefix_(pfx)
+    def replace_prefix_i(pfx)
       walk_members { |m| m.replace_prefix(pfx) }
       # propagate along chain using fast method
-      @next.replace_prefix_(pfx) unless @next.nil?
+      @next.replace_prefix_i(pfx) unless @next.nil?
     end
 
-    def _set_prefix_(pfx)
+    def set_prefix_i(pfx)
       @prefix = pfx
       # propagate along chain
-      self.next._set_prefix_(pfx) unless self.next.nil?
+      self.next.set_prefix_i(pfx) unless self.next.nil?
     end
 
     def search_self(_name)
@@ -620,7 +606,7 @@ module IDL::AST
       _key = _name.downcase.intern
       node = @introduced[_key]
       if not node.nil? and node.name != _name
-        raise RuntimeError, "\"#{_name}\" clashed with \"#{node.name}\"."
+        raise "\"#{_name}\" clashed with \"#{node.name}\"."
       end
       if node.nil? && @next
         node = @next.search_links(_name)
@@ -646,7 +632,6 @@ module IDL::AST
   end # Module
 
   class TemplateParam < Leaf
-    NAMETYPE = :class
     attr_reader :idltype, :concrete
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
@@ -671,24 +656,35 @@ module IDL::AST
       @concrete = _param
     end
 
-    def self.concrete_param(_context, _node)
-      if _node.is_template?
-        _cnode = if _node.is_a?(IDL::AST::TemplateParam)
-          _node.concrete
+    def concrete_matches?(idl_type)
+      if @concrete
+        concrete_type = (@concrete.is_a?(IDL::Type) ? @concrete : @concrete.idltype).resolved_type
+        return concrete_type.matches?(idl_type.resolved_type)
+      end
+      false
+    end
+
+    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?
+          tpl_elem.concrete # get the template parameter's concrete (instantiation argument) value
         else
-          # referenced template node should have been instantiated already and available through context
-          _context[_node]
+          # referenced template elements should have been instantiated already and available through context
+          ctxelem = instantiation_context[tpl_elem]
+          # all items in the context are AST elements but for a concrete parameter value only constants and type
+          # elements will be referenced; return accordingly
+          ctxelem.is_a?(IDL::AST::Const) ? ctxelem.expression : ctxelem.idltype
         end
-        raise RuntimeError, "cannot resolve concrete node for template #{_node.typename} #{_node.scoped_lm_name}" unless _cnode
-        _cnode
+        raise "cannot resolve concrete node for template #{tpl_elem.typename} #{tpl_elem.scoped_lm_name}" unless celem
+        celem
       else
-        _node
+        tpl_elem.idltype # just return the element's idltype if not from the template scope
       end
     end
   end
 
   class TemplateModule < Module
-    NAMETYPE = :class
     DEFINABLE = [
       IDL::AST::Include, 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,
@@ -716,17 +712,16 @@ module IDL::AST
       @template_params
     end
 
-    def instantiate(_module_instance, _context = {})
+    def instantiate(_module_instance, instantiation_context = {})
       # process concrete parameters
       @template_params.each_with_index do |_tp, _ix|
-        raise RuntimeError,
-              "missing template parameter for #{typename} #{scoped_lm_name}: #{_tp.name}" unless _ix < _module_instance.template_params.size
+        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 RuntimeError, "anonymous type definitions are not allowed!" if _cp.is_anonymous?
+          raise "anonymous type definitions are not allowed!" if _cp.is_anonymous?
           # parameter should be a matching IDL::Type
           unless _tp.idltype.is_a?(IDL::Type::Any) || _tp.idltype.class === _cp.resolved_type
-            raise RuntimeError, "mismatched instantiation parameter \##{_ix} #{_cp.typename} for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
+            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
@@ -746,27 +741,26 @@ module IDL::AST
                 # check basetype
                 unless _tptype.basetype.is_a?(IDL::Type::ScopedName) &&
                        _tptype.basetype.is_node?(IDL::AST::TemplateParam) &&
-                       _tptype.basetype.node.concrete &&
-                       _tptype.basetype.node.concrete.idltype.resolved_type == _cp.resolved_type.basetype.resolved_type
-                  raise RuntimeError, "invalid sequence type as instantiation parameter for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
+                       _tptype.basetype.node.concrete_matches?(_cp.resolved_type.basetype)
+                  raise "invalid sequence type as instantiation parameter for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
                 end
               end
           end
         elsif _cp.is_a?(IDL::Expression)
           # template param should be 'const <const_type>'
           unless _tp.idltype.is_a?(IDL::Type::Const)
-            raise RuntimeError, "unexpected expression as instantiation parameter for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
+            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
-          raise RuntimeError, "invalid instantiation parameter for #{typename} #{scoped_lm_name}: #{_cp.class.name}"
+          raise "invalid instantiation parameter for #{typename} #{scoped_lm_name}: #{_cp.class.name}"
         end
-        # if we  get here all is well -> store concrete param
-        _tp.set_concrete_param(_cp.is_a?(IDL::Type::ScopedName) ? _cp.node : _cp)
+        # if we  get here all is well -> store concrete param (either IDL type or expression)
+        _tp.set_concrete_param(_cp)
       end
       # instantiate template by copying template module state to module instance
-      _module_instance.copy_from(self, _context)
+      _module_instance.copy_from(self, instantiation_context)
     end
 
   protected
@@ -777,16 +771,15 @@ module IDL::AST
   end # TemplateModule
 
   class TemplateModuleReference < Leaf
-    NAMETYPE = :class
     def initialize(_name, _enclosure, _params)
       super(_name, _enclosure)
       unless _params[:tpl_type].is_a?(IDL::Type::ScopedName) && _params[:tpl_type].is_node?(IDL::AST::TemplateModule)
-        raise RuntimeError, "templated module reference type required for #{typename} #{scoped_lm_name}: got #{_params[:tpl_type].typename}"
+        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)
-          raise RuntimeError, "invalid template module parameter for template module reference #{typename} #{scoped_lm_name}: #{p.typename}"
+          raise "invalid template module parameter for template module reference #{typename} #{scoped_lm_name}: #{p.typename}"
         end
       end
       @params = _params[:tpl_params].collect { |p| p.resolved_node }
@@ -802,14 +795,13 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       inst_params = @params.collect do |tp|
-        # concrete objects are either Expression or Node; latter needs to be repacked as IDL::Type::ScopedName
-        # as that is what the TemplateModule#instantiate expects
-        tp.concrete.is_a?(IDL::Expression) ? tp.concrete : IDL::Type::ScopedName.new(tp.concrete)
+        # 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 })
-      @template.instantiate(mod_inst, _context)
+      @template.instantiate(mod_inst, instantiation_context)
       mod_inst
     end
 
@@ -829,7 +821,10 @@ module IDL::AST
       #overrule
       @scopes = @enclosure.scopes
       @scoped_name = @scopes.collect{|s| s.name}.join("::")
-      @scoped_lm_name = @scopes.collect{|s| s.lm_name}.join("::")
+    end
+
+    def lm_scopes
+      @lm_scopes ||= @enclosure.lm_scopes
     end
 
     def marshal_dump
@@ -844,16 +839,11 @@ module IDL::AST
       #overrule
       @scopes = @enclosure.scopes || []
       @scoped_name = @scopes.collect{|s| s.name}.join("::")
-      @scoped_lm_name = @scopes.collect{|s| s.lm_name}.join("::")
     end
 
     def is_defined?; @defined; end
     def is_preprocessed?; @preprocessed; end
 
-    def repo_scopes
-      @repo_scopes ||= (@enclosure.nil? ? [] : @enclosure.repo_scopes.dup)
-    end
-
     def introduce(node)
       @enclosure.introduce(node) unless node == self
     end
@@ -867,7 +857,7 @@ module IDL::AST
     end
 
   protected
-    def copy_from(_template, _context)
+    def copy_from(_template, instantiation_context)
       super
       @filename = _template.filename
       @defined = _template.is_defined?
@@ -875,7 +865,6 @@ module IDL::AST
       #overrule
       @scopes = @enclosure.scopes
       @scoped_name = @scopes.collect{|s| s.name}.join("::")
-      @scoped_lm_name = @scopes.collect{|s| s.lm_name}.join("::")
       self
     end
 
@@ -923,8 +912,8 @@ module IDL::AST
         # 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(", ")
-          raise RuntimeError, "\"#{_name}\" is ambiguous. " + s
+          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
       results.first
@@ -954,7 +943,6 @@ module IDL::AST
   end # Derivable
 
   class Interface < Derivable
-    NAMETYPE = :class
     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
@@ -987,17 +975,17 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    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(_context)
+        :inherits => self.concrete_bases(instantiation_context)
       }
       # instantiate concrete interface def and validate
       # concrete bases
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
 
     def is_abstract?; @abstract; end
@@ -1009,38 +997,30 @@ module IDL::AST
     def add_bases(inherits_)
       inherits_.each do |tc|
         unless tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::TemplateParam)
-          unless (tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::Interface))
-            raise RuntimeError,
-                  "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
+          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 RuntimeError,
-                  "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
+            raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
           end
           if not rtc.node.is_defined?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            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?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot inherit from 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if rtc.node.is_pseudo? and not self.is_pseudo?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot inherit from 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if self.is_abstract? and not rtc.node.is_abstract?
-            raise RuntimeError,
-                  "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if self.is_local? and rtc.node.is_abstract?
-            raise RuntimeError,
-                  "'local' #{typename} #{scoped_lm_name} cannot inherit from 'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "'local' #{typename} #{scoped_lm_name} cannot inherit from 'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if self.has_base?(rtc.node)
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
+            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) }
@@ -1050,8 +1030,7 @@ module IDL::AST
               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) }
-              raise RuntimeError,
-                    "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
+              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
           end
@@ -1069,13 +1048,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
@@ -1086,7 +1065,7 @@ module IDL::AST
         case node
         when IDL::AST::Struct, IDL::AST::Union
           if node.is_defined?
-            raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+            raise "#{node.typename} \"#{node.name}\" is already defined."
           end
           node.annotations.concat(params[:annotations])
 
@@ -1105,13 +1084,13 @@ module IDL::AST
 
           return _new_node
         else
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
       end
 
       case node
       when IDL::AST::Operation, IDL::AST::Attribute
-        raise RuntimeError, "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
+        raise "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
       else
         newnode = node.class.new(node.name, self, params)
         newnode.annotations.concat(params[:annotations])
@@ -1123,10 +1102,10 @@ module IDL::AST
 
   protected
 
-    def concrete_bases(_context)
+    def concrete_bases(instantiation_context)
       # collect all bases and resolve any template param types
-      @bases.collect do |_base|
-        IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, _base))
+      @bases.collect do |base|
+        IDL::AST::TemplateParam.concrete_param(instantiation_context, base)
       end
     end
 
@@ -1136,7 +1115,6 @@ module IDL::AST
   end # Interface
 
   class ComponentBase < Derivable
-    NAMETYPE = :class
     DEFINABLE = []
     attr_reader :base
     attr_reader :interfaces
@@ -1165,24 +1143,22 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure, _params = {})
+    def instantiate(instantiation_context, _enclosure, _params = {})
       _params.merge!({
-        :base => @base ? IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, @base)) : @base,
-        :supports => self.concrete_interfaces(_context)
+        :base => @base ? IDL::AST::TemplateParam.concrete_param(instantiation_context, @base) : @base,
+        :supports => self.concrete_interfaces(instantiation_context)
       })
       # instantiate concrete def and validate
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
 
     def set_base(parent)
       unless parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(IDL::AST::TemplateParam)
-        unless (parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(self.class))
-          raise RuntimeError,
-                "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
+        unless (parent.is_a?(IDL::Type::NodeType) && parent.is_node?(self.class))
+          raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
         end
         if parent.resolved_type.node.has_base?(self)
-          raise RuntimeError,
-                "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
+          raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
         end
         @resolved_base = parent.resolved_type.node
       end
@@ -1201,22 +1177,18 @@ module IDL::AST
       intfs.each do |tc|
         unless tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::TemplateParam)
           unless (tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::Interface))
-            raise RuntimeError,
-                  "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
+            raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
           end
           rtc = tc.resolved_type
           if not rtc.node.is_defined?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot support forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           ## TODO : is this legal?
           if rtc.node.is_local?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot support 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if rtc.node.is_pseudo?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            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?
@@ -1224,8 +1196,7 @@ module IDL::AST
           #        "'abstract' #{typename} #{scoped_lm_name} cannot support 'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           #end
           if self.has_support?(rtc.node)
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
+            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) }
@@ -1235,8 +1206,7 @@ module IDL::AST
               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) }
-              raise RuntimeError,
-                    "#{typename} #{scoped_lm_name} cannot support #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
+              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
           end
@@ -1259,7 +1229,7 @@ module IDL::AST
         case node
         when IDL::AST::Struct, IDL::AST::Union
           if node.is_defined?
-            raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+            raise "#{node.typename} \"#{node.name}\" is already defined."
           end
           node.annotations.concat(params[:annotations])
 
@@ -1278,13 +1248,13 @@ module IDL::AST
 
           return _new_node
         else
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
       end
 
       case node
       when IDL::AST::Operation, IDL::AST::Attribute
-        raise RuntimeError, "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
+        raise "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
       else
         newnode = node.class.new(node.name, self, params)
         newnode.annotations.concat(params[:annotations])
@@ -1300,16 +1270,15 @@ module IDL::AST
       (@resolved_base ? [@resolved_base] : []).concat(@resolved_interfaces)
     end
 
-    def concrete_interfaces(_context)
+    def concrete_interfaces(instantiation_context)
       # collect all bases and resolve any template param types
       @interfaces.collect do |_intf|
-        IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, _intf))
+        IDL::AST::TemplateParam.concrete_param(instantiation_context, _intf)
       end
     end
   end # ComponentBase
 
   class Home < ComponentBase
-    NAMETYPE = :class
     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
@@ -1337,34 +1306,31 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params  = {
-        :component => IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, @component)),
-        :primarykey => @primarykey ? IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, @primarykey)) : @primarykey
+        :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(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
 
     def set_component_and_key(comp, key)
       unless comp && comp.is_a?(IDL::Type::ScopedName) && comp.is_node?(IDL::AST::TemplateParam)
         unless comp && comp.is_a?(IDL::Type::ScopedName) && comp.is_node?(IDL::AST::Component)
-          raise RuntimeError,
-                (comp ?
+          raise (comp ?
                   "invalid managed component for #{typename} #{scoped_lm_name}: #{comp.typename}" :
                   "missing managed component specification for #{typename} #{scoped_lm_name}")
         end
         unless comp.resolved_type.node.is_defined?
-          raise RuntimeError,
-            "#{scoped_lm_name}: #{comp.typename} cannot manage forward declared component #{comp.node.scoped_lm_name}"
+          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 && key.is_a?(IDL::Type::ScopedName) && key.is_node?(IDL::AST::TemplateParam)
         ## TODO : add check for Components::PrimaryKeyBase base type
         unless key.nil? || (key.is_a?(IDL::Type::ScopedName) && key.is_node?(IDL::AST::Valuetype))
-          raise RuntimeError,
-            "invalid primary key for #{typename} #{scoped_lm_name}: #{key.typename}"
+          raise "invalid primary key for #{typename} #{scoped_lm_name}: #{key.typename}"
         end
         @resolved_pk = key.resolved_type.node if key
       end
@@ -1372,13 +1338,13 @@ module IDL::AST
       @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
@@ -1387,7 +1353,6 @@ module IDL::AST
   end # Home
 
   class Connector < ComponentBase
-    NAMETYPE = :class
     DEFINABLE = [IDL::AST::Attribute, IDL::AST::Port]
 
     def initialize(_name, _enclosure, params)
@@ -1403,34 +1368,32 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       # instantiate concrete connector def and validate
-      super(_context, _enclosure, {})
+      super(instantiation_context, _enclosure, {})
     end
 
     def is_defined?; true; end
     def is_forward?; false; end
 
     def add_interfaces(intfs)
-      raise RuntimeError, "interface support not allowed for #{typename} #{scoped_lm_name}" if intfs && !intfs.empty?
+      raise "interface support not allowed for #{typename} #{scoped_lm_name}" if intfs && !intfs.empty?
     end
 
     def set_base(parent)
       unless parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(IDL::AST::TemplateParam)
-        if not (parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(self.class))
-          raise RuntimeError,
-                "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
+        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 RuntimeError,
-                "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
+          raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
         end
       end
       @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
@@ -1439,7 +1402,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)
@@ -1468,7 +1431,6 @@ module IDL::AST
   end # Connector
 
   class Component < ComponentBase
-    NAMETYPE = :class
     DEFINABLE = [IDL::AST::Attribute, IDL::AST::Port]
 
     def initialize(_name, _enclosure, params)
@@ -1486,9 +1448,9 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       # instantiate concrete component def and validate
-      super(_context, _enclosure, { :forward => self.is_forward? })
+      super(instantiation_context, _enclosure, { :forward => self.is_forward? })
     end
 
     def is_defined?; @defined; end
@@ -1496,24 +1458,21 @@ module IDL::AST
 
     def set_base(parent)
       unless parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(IDL::AST::TemplateParam)
-        if not (parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(self.class))
-          raise RuntimeError,
-                "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
+        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?
-          raise RuntimeError,
-                "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{parent.node.typename} #{parent.node.scoped_lm_name}"
+          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)
-          raise RuntimeError,
-                "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
+          raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
         end
       end
       @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
@@ -1522,11 +1481,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)
@@ -1555,7 +1514,6 @@ module IDL::AST
   end # Component
 
   class Porttype < Node
-    NAMETYPE = :class
     DEFINABLE = [IDL::AST::Attribute, IDL::AST::Port]
     attr_reader :idltype
     def initialize(_name, _enclosure, params)
@@ -1571,13 +1529,12 @@ module IDL::AST
       @children.select {|c| IDL::AST::Attribute === c}
     end
 
-    def instantiate(_context, _enclosure)
-      super(_context, _enclosure, {})
+    def instantiate(instantiation_context, _enclosure)
+      super(instantiation_context, _enclosure, {})
     end
   end # Porttype
 
   class Port < Leaf
-    NAMETYPE = :member
     PORTTYPES = [:facet, :receptacle, :emitter, :publisher, :consumer, :port, :mirrorport]
     PORT_MIRRORS = {:facet => :receptacle, :receptacle => :facet}
     EXTPORTDEF_ANNOTATION = 'ExtendedPortDef'
@@ -1587,32 +1544,32 @@ module IDL::AST
       super(_name, _enclosure)
       @idltype  = params[:type]
       @porttype = params[:porttype]
-      raise RuntimeError, "unknown porttype for  #{typename} #{scoped_lm_name}: #{@porttype}" unless PORTTYPES.include?(@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) ||
-              (@idltype.is_a?(IDL::Type::ScopedName) && (@idltype.is_node?(IDL::AST::Interface) || @idltype.is_node?(IDL::AST::TemplateParam)))
-          raise RuntimeError, "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
+              (@idltype.is_a?(IDL::Type::NodeType) && (@idltype.is_node?(IDL::AST::Interface) || @idltype.is_node?(IDL::AST::TemplateParam)))
+          raise "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
         end
       when :port, :mirrorport
-        unless @idltype.is_a?(IDL::Type::ScopedName) && (@idltype.is_node?(IDL::AST::Porttype) || @idltype.is_node?(IDL::AST::TemplateParam))
-          raise RuntimeError, "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
+        unless @idltype.is_a?(IDL::Type::NodeType) && (@idltype.is_node?(IDL::AST::Porttype) || @idltype.is_node?(IDL::AST::TemplateParam))
+          raise "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
         end
       else
-        unless @idltype.is_a?(IDL::Type::ScopedName) && (@idltype.is_node?(IDL::AST::Eventtype) ||  @idltype.is_node?(IDL::AST::TemplateParam))
-          raise RuntimeError, "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
+        unless @idltype.is_a?(IDL::Type::NodeType) && (@idltype.is_node?(IDL::AST::Eventtype) || @idltype.is_node?(IDL::AST::TemplateParam))
+          raise "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
         end
       end
       @multiple = params[:multiple] ? true : false
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(_context),
+        :type => @idltype.instantiate(instantiation_context),
         :porttype => @porttype,
         :multiple => @multiple
       }
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
 
     def multiple?
@@ -1657,7 +1614,6 @@ module IDL::AST
   end # Port
 
   class Valuebox < Leaf
-    NAMETYPE = :class
     attr_reader :idltype, :boxed_type
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
@@ -1665,8 +1621,7 @@ module IDL::AST
       @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 RuntimeError,
-            "boxing valuetype #{@boxed_type.scoped_lm_name} in Valuebox #{scoped_lm_name} not allowed"
+          raise "boxing valuetype #{@boxed_type.scoped_lm_name} in Valuebox #{scoped_lm_name} not allowed"
         end
       end
     end
@@ -1685,16 +1640,15 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @boxed_type.instantiate(_context)
+        :type => @boxed_type.instantiate(instantiation_context)
       }
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
   end # Valuebox
 
   class Valuetype < Derivable
-    NAMETYPE = :class
     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
@@ -1721,8 +1675,7 @@ module IDL::AST
         _base = _inherits[:base] || {}
         @truncatable = _base[:truncatable] || false
         if @custom && @truncatable
-            raise RuntimeError,
-                  "'truncatable' attribute *not* allowed for 'custom' #{typename} #{scoped_lm_name}"
+            raise "'truncatable' attribute *not* allowed for 'custom' #{typename} #{scoped_lm_name}"
         end
         add_bases(_base[:list] || [])
         add_interfaces(_inherits[:supports] || [])
@@ -1752,7 +1705,7 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
         :forward => self.is_forward?,
         :abstract => self.is_abstract?,
@@ -1760,12 +1713,12 @@ module IDL::AST
         :inherits => {
           :base => {
             :truncatable => self.is_truncatable?,
-            :list => self.concrete_bases(_context)
+            :list => self.concrete_bases(instantiation_context)
           },
-          :supports => self.concrete_interfaces(_context)
+          :supports => self.concrete_interfaces(instantiation_context)
         }
       }
-      inst = super(_context, _enclosure, _params)
+      inst = super(instantiation_context, _enclosure, _params)
       inst.defined = true
       inst
     end
@@ -1822,33 +1775,26 @@ module IDL::AST
       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))
-            raise RuntimeError,
-                  "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
+            raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
           end
           rtc = tc.resolved_type
           if rtc.node.has_ancestor?(self)
-            raise RuntimeError,
-                  "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
+            raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
           end
           if not rtc.node.is_defined?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            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?
-            raise RuntimeError,
-                  "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if (not self.is_custom?) and rtc.node.is_custom?
-            raise RuntimeError,
-                  "non-'custom' #{typename} #{scoped_lm_name} cannot inherit from 'custom' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "non-'custom' #{typename} #{scoped_lm_name} cannot inherit from 'custom' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if @resolved_bases.include?(rtc.node)
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
+            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
-            raise RuntimeError,
-                  "concrete basevalue #{tc.node.typename} #{tc.node.scoped_lm_name} MUST "+
+            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
           @resolved_bases << rtc.node
@@ -1861,18 +1807,15 @@ module IDL::AST
       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))
-            raise RuntimeError,
-                  "invalid support identifier for #{typename} #{scoped_lm_name}: #{if_.typename}"
+            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
-            raise RuntimeError,
-                  "concrete interface '#{rif_.node.scoped_lm_name}' inheritance not allowed for #{typename} #{scoped_lm_name}. Valuetypes can only inherit (support) a single concrete interface."
+            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 RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support concrete interface #{rif_.node.scoped_lm_name} because it does not derive from inherited concrete interfaces"
+            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
@@ -1894,7 +1837,7 @@ module IDL::AST
 
     def define(_type, _name, *args)
       if self.is_abstract? && [IDL::AST::StateMember, IDL::AST::Initializer].include?(_type)
-        raise RuntimeError, "cannot define statemember #{_name} on abstract #{typename} #{scoped_lm_name}"
+        raise "cannot define statemember #{_name} on abstract #{typename} #{scoped_lm_name}"
       end
       super(_type, _name, *args)
     end
@@ -1931,7 +1874,7 @@ module IDL::AST
         case node
         when IDL::AST::Struct, IDL::AST::Union
           if node.is_defined?
-            raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+            raise "#{node.typename} \"#{node.name}\" is already defined."
           end
           node.annotations.concat(params[:annotations])
 
@@ -1950,13 +1893,13 @@ module IDL::AST
 
           return _new_node
         else
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
       end
 
       case node
       when IDL::AST::Operation, IDL::AST::Attribute, IDL::AST::StateMember, IDL::AST::Initializer
-        raise RuntimeError, "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
+        raise "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
       else
         newnode = node.class.new(node.name, self, params)
         newnode.annotations.concat(params[:annotations])
@@ -1975,16 +1918,16 @@ module IDL::AST
       @resolved_bases
     end
 
-    def concrete_bases(_context)
+    def concrete_bases(instantiation_context)
       # collect all bases and resolve any template param types
       @bases.collect do |_base|
-        IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, _base))
+        IDL::AST::TemplateParam.concrete_param(instantiation_context, _base)
       end
     end
 
-    def concrete_interfaces(_context)
+    def concrete_interfaces(instantiation_context)
       @interfaces.collect do |_intf|
-        IDL::Type::ScopedName.new(IDL::AST::TemplateParam.concrete_param(_context, _intf))
+        IDL::AST::TemplateParam.concrete_param(instantiation_context, _intf)
       end
     end
   end # Valuetype
@@ -1998,16 +1941,15 @@ module IDL::AST
   end # Eventtype
 
   class StateMember < Leaf
-    NAMETYPE = :member
     attr_reader :idltype, :visibility
     def initialize(_name, _enclosure, params)
       @is_recursive = false
       @has_incomplete_type = false
       super(_name, _enclosure)
-      @idltype  = params[:type]
+      @idltype = params[:type]
       @visibility = (params[:visibility] == :public ? :public : :private)
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
         ## check for use of incomplete types
         if !@idltype.is_complete?
           ## verify type is used in sequence
@@ -2063,7 +2005,7 @@ module IDL::AST
             @has_incomplete_type = true
             return
           end
-          raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+          raise "Incomplete type #{@idltype.typename} not allowed here!"
         end
       end
     end
@@ -2080,12 +2022,12 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(_context),
+        :type => @idltype.instantiate(instantiation_context),
         :visibility => self.visibility
       }
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
 
     def is_local?(recurstk)
@@ -2106,7 +2048,6 @@ module IDL::AST
   end # StateMember
 
   class Initializer < Leaf
-    NAMETYPE = :member
     attr_reader :raises, :params
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
@@ -2121,7 +2062,7 @@ module IDL::AST
       exlist.each do |extype|
         unless extype.is_a?(IDL::Type::ScopedName) &&
                   (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
-          raise RuntimeError, 'Only IDL Exception types allowed in raises declaration.'
+          raise 'Only IDL Exception types allowed in raises declaration.'
         end
         @raises << extype
       end
@@ -2137,28 +2078,28 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :raises => self.concrete_raises(_context)
+        :raises => self.concrete_raises(instantiation_context)
       }
-      _init = super(_context, _enclosure, _params)
-      _init.set_concrete_parameters(_context, @params)
+      _init = super(instantiation_context, _enclosure, _params)
+      _init.set_concrete_parameters(instantiation_context, @params)
       _init
     end
 
   protected
 
-    def concrete_raises(_context)
+    def concrete_raises(instantiation_context)
       @raises.collect do |ex|
-        ex.instantiate(_context)
+        ex.instantiate(instantiation_context)
       end
     end
 
-    def set_concrete_parameters(_context, parms)
+    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(_context) })
+                             :type => parm.idltype.instantiate(instantiation_context) })
       end
     end
 
@@ -2168,17 +2109,15 @@ module IDL::AST
   end # Finder
 
   class Const < Leaf
-    NAMETYPE = :class
     attr_reader :idltype, :expression, :value
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
-      @idltype  = params[:type]
+      @idltype = params[:type]
       @expression = params[:expression]
       @value = nil
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
-        raise RuntimeError,
-              "Incomplete type #{@idltype.typename} not allowed here!" if !@idltype.is_complete?
+        raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
+        raise "Incomplete type #{@idltype.typename} not allowed here!" if !@idltype.is_complete?
         unless @expression.is_a?(IDL::Expression::ScopedName) && @expression.is_node?(IDL::AST::TemplateParam)
           @value = @idltype.narrow(@expression.value)
         end
@@ -2200,17 +2139,16 @@ module IDL::AST
       end
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(_context),
-        :expression => @expression.instantiate(_context)
+        :type => @idltype.instantiate(instantiation_context),
+        :expression => @expression.instantiate(instantiation_context)
       }
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
   end # Const
 
   class Parameter < Leaf
-    NAMETYPE = :member
     IN, OUT, INOUT = 0, 1, 2
     ATTRIBUTE_MAP = {
       :in => IN,
@@ -2220,23 +2158,22 @@ module IDL::AST
     attr_reader :idltype
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
-      @idltype  = params[:type]
+      @idltype = params[:type]
       @attribute = params[:attribute]
       unless ATTRIBUTE_MAP.has_key?(@attribute)
-        raise RuntimeError,
-          "invalid attribute for parameter: #{params[:attribute]}"
+        raise "invalid attribute for parameter: #{params[:attribute]}"
       end
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
         if @idltype.is_local?
           if _enclosure.enclosure.is_a?(IDL::AST::Interface) && !_enclosure.enclosure.is_local?
-            raise RuntimeError, "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
+            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?
           if _enclosure.enclosure.is_a?(IDL::AST::Interface)
-            raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+            raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
@@ -2257,40 +2194,39 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(_context),
+        :type => @idltype.instantiate(instantiation_context),
         :attribute => @attribute
       }
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
   end # Parameter
 
   class Operation < Node
-    NAMETYPE = :member
     DEFINABLE = [IDL::AST::Parameter]
     attr_reader :idltype, :oneway, :raises
     attr_accessor :context
 
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
-      @idltype  = params[:type]
+      @idltype = params[:type]
       @oneway = (params[:oneway] == true)
       @in = []
       @out = []
       @raises = []
       @context = nil
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+        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 RuntimeError, "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
+            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?
           if _enclosure.is_a?(IDL::AST::Interface)
-            raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+            raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
@@ -2311,13 +2247,13 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(_context),
+        :type => @idltype.instantiate(instantiation_context),
         :oneway => @oneway,
       }
-      _op = super(_context, _enclosure, _params)
-      _op.raises = self.concrete_raises(_context)
+      _op = super(instantiation_context, _enclosure, _params)
+      _op.raises = self.concrete_raises(instantiation_context)
       _op.context = @context
       _op
     end
@@ -2326,7 +2262,7 @@ module IDL::AST
       exlist.each do |extype|
         unless extype.is_a?(IDL::Type::ScopedName) &&
                 (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
-          raise RuntimeError, 'Only IDL Exception or Native types allowed in raises declaration.'
+          raise 'Only IDL Exception or Native types allowed in raises declaration.'
         end
         @raises << extype
       end
@@ -2358,13 +2294,13 @@ module IDL::AST
 
   protected
 
-    def concrete_raises(_context)
+    def concrete_raises(instantiation_context)
       @raises.collect do |ex|
-        ex.instantiate(_context)
+        ex.instantiate(instantiation_context)
       end
     end
 
-    def copy_from(_template, _context)
+    def copy_from(_template, instantiation_context)
       super
       self.walk_members do |param|
         case param.attribute
@@ -2384,23 +2320,22 @@ module IDL::AST
   class Attribute < Leaf
     attr_reader :idltype, :readonly
     attr_reader :get_raises, :set_raises
-    NAMETYPE = :member
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
-      @idltype  = params[:type]
+      @idltype = params[:type]
       @get_raises = []
       @set_raises = []
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
         if @idltype.is_local?
           if _enclosure.is_a?(IDL::AST::Interface) && !_enclosure.is_local?
-            raise RuntimeError, "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
+            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?
           if _enclosure.is_a?(IDL::AST::Interface)
-            raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+            raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
@@ -2420,14 +2355,14 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :type => @idltype.instantiate(_context),
+        :type => @idltype.instantiate(instantiation_context),
         :readonly => @readonly
       }
-      _att = super(_context, _enclosure, _params)
-      _att.get_raises = self.concrete_get_raises(_context)
-      _att.set_raises = self.concrete_set_raises(_context)
+      _att = super(instantiation_context, _enclosure, _params)
+      _att.get_raises = self.concrete_get_raises(instantiation_context)
+      _att.set_raises = self.concrete_set_raises(instantiation_context)
       _att
     end
 
@@ -2435,7 +2370,7 @@ module IDL::AST
       exlist.each do |extype|
         unless extype.is_a?(IDL::Type::ScopedName) &&
                   (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
-          raise RuntimeError, 'Only IDL Exception types allowed in raises declaration.' unless extype.resolved_type.node.is_a?(IDL::AST::Exception)
+          raise 'Only IDL Exception types allowed in raises declaration.' unless extype.resolved_type.node.is_a?(IDL::AST::Exception)
         end
         @get_raises << extype
       end
@@ -2445,7 +2380,7 @@ module IDL::AST
       exlist.each do |extype|
         unless extype.is_a?(IDL::Type::ScopedName) &&
                   (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
-          raise RuntimeError, 'Only IDL Exception types allowed in raises declaration.' unless extype.resolved_type.node.is_a?(IDL::AST::Exception)
+          raise 'Only IDL Exception types allowed in raises declaration.' unless extype.resolved_type.node.is_a?(IDL::AST::Exception)
         end
         @set_raises << extype
       end
@@ -2460,21 +2395,20 @@ module IDL::AST
 
   protected
 
-    def concrete_get_raises(_context)
+    def concrete_get_raises(instantiation_context)
       @get_raises.collect do |ex|
-        ex.instantiate(_context)
+        ex.instantiate(instantiation_context)
       end
     end
 
-    def concrete_set_raises(_context)
+    def concrete_set_raises(instantiation_context)
       @set_raises.collect do |ex|
-        ex.instantiate(_context)
+        ex.instantiate(instantiation_context)
       end
     end
   end # Attribute
 
   class Struct < Node
-    NAMETYPE = :class
     DEFINABLE = [IDL::AST::Member, IDL::AST::Struct, IDL::AST::Union, IDL::AST::Enum, IDL::AST::Enumerator]
     attr_reader :idltype
     def initialize(_name, _enclosure, params)
@@ -2520,11 +2454,11 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
         :forward => @forward
       }
-      _s = super(_context, _enclosure, _params)
+      _s = super(instantiation_context, _enclosure, _params)
       _s.defined = self.is_defined?
       _s
     end
@@ -2546,12 +2480,11 @@ module IDL::AST
 
   class Member < Leaf
     attr_reader :idltype
-    NAMETYPE = :member
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype  = params[:type]
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
         ## check for use of incomplete types
         if !@idltype.is_complete?
           ## verify type is used in sequence
@@ -2585,7 +2518,7 @@ module IDL::AST
               end
             end
           end
-          raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+          raise "Incomplete type #{@idltype.typename} not allowed here!"
         end
       end
     end
@@ -2603,16 +2536,15 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure, _params = {})
+    def instantiate(instantiation_context, _enclosure, _params = {})
       _params.merge!({
-        :type => @idltype.instantiate(_context),
+        :type => @idltype.instantiate(instantiation_context),
       })
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
   end # Member
 
   class Union < Node
-    NAMETYPE = :class
     DEFINABLE = [IDL::AST::UnionMember, IDL::AST::Struct, IDL::AST::Union, IDL::AST::Enum, IDL::AST::Enumerator]
     attr_reader :idltype
     attr_accessor :switchtype
@@ -2677,16 +2609,14 @@ module IDL::AST
         ## check union case labels for validity
         m.labels.each { |lbl|
           if lbl == :default
-            raise RuntimeError,
-                  "duplicate case label 'default' for #{typename} #{lm_name}" if 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 RuntimeError,
-                    "duplicate case label #{lv.to_s} for #{typename} #{lm_name}"
+              raise "duplicate case label #{lv.to_s} for #{typename} #{lm_name}"
             end
             labelvals << lv
           end
@@ -2695,8 +2625,7 @@ module IDL::AST
       ## check if default allowed if defined
       if default_
         if @switchtype.resolved_type.range_length == labelvals.size
-          raise RuntimeError,
-                "'default' case label superfluous for #{typename} #{lm_name}"
+          raise "'default' case label superfluous for #{typename} #{lm_name}"
         end
       end
     end
@@ -2714,12 +2643,12 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
         :forward => @forward
       }
-      _u = super(_context, _enclosure, _params)
-      _u.set_switchtype(@switchtype.instantiate(_context))
+      _u = super(instantiation_context, _enclosure, _params)
+      _u.set_switchtype(@switchtype.instantiate(instantiation_context))
       _u.validate_labels
       _u.defined = self.is_defined?
       _u
@@ -2733,7 +2662,6 @@ module IDL::AST
   end # Union
 
   class UnionMember < Member
-    NAMETYPE = :member
     attr_reader :labels
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure, params)
@@ -2754,16 +2682,15 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    def instantiate(instantiation_context, _enclosure)
       _params = {
-        :labels => @labels.collect { |l| l == :default ? l : l.instantiate(_context) },
+        :labels => @labels.collect { |l| l == :default ? l : l.instantiate(instantiation_context) },
       }
-      super(_context, _enclosure, _params)
+      super(instantiation_context, _enclosure, _params)
     end
   end # UnionMember
 
   class Enum < Leaf
-    NAMETYPE = :class
     attr_reader :idltype
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
@@ -2789,17 +2716,17 @@ module IDL::AST
       @enums << n
     end
 
-    def instantiate(_context, _enclosure)
-      super(_context, _enclosure, {})
+    def instantiate(instantiation_context, _enclosure)
+      super(instantiation_context, _enclosure, {})
     end
+
   end # Enum
 
   class Enumerator < Leaf
-    NAMETYPE = :class
     attr_reader :idltype, :enum, :value
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
-      @idltype  = IDL::Type::ULong.new
+      @idltype = IDL::Type::ULong.new
       @enum = params[:enum]
       @value = params[:value]
       @enum.add_enumerator(self)
@@ -2816,14 +2743,16 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
-      super(_context, _enclosure, { :enum => @enum, :value => @value })
+    def instantiate(instantiation_context, _enclosure)
+      # 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 })
     end
   end # Enumerator
 
   class Typedef < Leaf
     attr_reader :idltype
-    NAMETYPE = :class
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype  = params[:type]
@@ -2842,8 +2771,8 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
-      super(_context, _enclosure, { :type => @idltype.instantiate(_context) })
+    def instantiate(instantiation_context, _enclosure)
+      super(instantiation_context, _enclosure, { :type => @idltype.instantiate(instantiation_context) })
     end
   end # Typedef
 end