ridl 2.7.1 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87ce802ae63d060ff0417d998795740726aaf67f631484735aa56191404bf78d
-  data.tar.gz: 888f4de7ff1a2146928c42b60298d6662d765dd7406c43287457182a81deb4ab
+  metadata.gz: be5b79c10b3a4bb8e2f0404004ec5201332bef859fc69c636c4750e8eb6f6b13
+  data.tar.gz: 0a23918976bfb9b7db6595409d974fc80be2b5a686f8b40220fa689edd9cc791
 SHA512:
-  metadata.gz: d3c4384299da19d91f593c578003615949962270392ee9293296341bd15ccf72c29cd8e304feefc777d2d408b36b67c830f44154b27d86589c98b79e32ec9e7d
-  data.tar.gz: 8717656df74c22c74e23acbf8e80748e646ece8be1e68131126c5d58e64ce093c038e9687b44c8042a119bc66bbb2b77ab73001a7678b234ca1b7f6c8d5710e0
+  metadata.gz: a187e41cc1d3c1d77f79f2ed9e43dccc4b83bc89b98ed4e2771627b2b1b771ba26390624f9abf779e1e2c5c89d7776698045408ca3ceb8ca9f10ecf87c6d0db6
+  data.tar.gz: b90d9a055d29d2de3dcee867df3ca57a26c8ddefd5b77fc3ff1a8a3ab7f645b395d8359c93b8a8a65122b006a76cd9f89815141239cd8e335cf21a78916b89b7

data/README.rdoc

@@ -1,5 +1,5 @@
 {<img src="https://badge.fury.io/rb/ridl.svg" alt="Gem Version" />}[https://badge.fury.io/rb/ridl]
-{<img src="https://dev.azure.com/remedyit/axcioma/_apis/build/status/ridl?branchName=master" alt="Azure pipeline" />}[https://dev.azure.com/remedyit/axcioma/_build?definitionId=7&_a=summary]
+{<img src="https://github.com/RemedyIT/ridl/workflows/linux/badge.svg" alt="Linux CI" />}[https://github.com/RemedyIT/ridl/actions?query=workflow%3Alinux]
 {<img src="https://www.codefactor.io/repository/github/remedyit/ridl/badge" alt="CodeFactor" />}[https://www.codefactor.io/repository/github/remedyit/ridl]
 
 = RIDL Compiler

data/lib/ridl/delegate.rb

@@ -205,10 +205,6 @@ class Delegator
     end
   end
 
-  def cur_parsed_name_scope
-    @cur ? @cur.parsed_name_scope : ''
-  end
-
   def is_included?(s)
     @includes.has_key?(s)
   end
@@ -288,8 +284,8 @@ class Delegator
 
   def define_module(name)
     @cur = @cur.define(IDL::AST::Module, name)
-    @cur.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
+    @cur.annotations.concat(@annotation_stack)
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur
   end
@@ -307,8 +303,8 @@ class Delegator
       raise "no scoped identifier allowed for template module: #{(global ? '::' : '')+names.join('::')}"
     end
     @cur = @cur.define(IDL::AST::TemplateModule, names[0])
-    @cur.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
+    @cur.annotations.concat(@annotation_stack)
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur
   end
@@ -321,8 +317,8 @@ class Delegator
       define_template_module(*tmp)
     end
     params = { :type => type }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::TemplateParam, name, params))
     @cur
   end
@@ -336,8 +332,8 @@ class Delegator
     end
     params = { :template => template_type.node, :template_params => parameters }
     mod_inst = @cur.define(IDL::AST::Module, name, params)
-    mod_inst.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
+    mod_inst.annotations.concat(@annotation_stack)
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(mod_inst.template.instantiate(mod_inst))
     @cur
   end
@@ -346,8 +342,8 @@ class Delegator
     params = {}
     params[:tpl_type] = type
     params[:tpl_params] = tpl_params || []
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::TemplateModuleReference, name, params))
     @cur
   end
@@ -371,8 +367,8 @@ class Delegator
     params[:pseudo] = attrib == :pseudo
     params[:forward] = false
     params[:inherits] = inherits
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Interface, name, params)
   end
@@ -387,8 +383,8 @@ class Delegator
     params[:component] = component
     params[:key] = key
     params[:supports] = supports || []
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Home, name, params)
   end
@@ -410,8 +406,8 @@ class Delegator
     params = {}
     params[:base] = base
     params[:supports] = supports || []
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Component, name, params)
   end
@@ -424,8 +420,8 @@ class Delegator
   def define_connector(name, base = nil)
     params = {}
     params[:base] = base
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Connector, name, params)
   end
@@ -437,8 +433,8 @@ class Delegator
 
   def define_porttype(name)
     params = {}
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Porttype, name, params)
   end
@@ -453,8 +449,8 @@ class Delegator
     params[:porttype] = porttype
     params[:type] = type
     params[:multiple] = multiple
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Port, name, params))
     @cur
   end
@@ -475,8 +471,8 @@ class Delegator
     params[:custom] = attrib == :custom
     params[:forward] = false
     params[:inherits] = inherits
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Eventtype, name, params)
     @cur
@@ -498,8 +494,8 @@ class Delegator
     params[:custom] = attrib == :custom
     params[:forward] = false
     params[:inherits] = inherits
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Valuetype, name, params)
     @cur
@@ -518,16 +514,16 @@ class Delegator
     params = {}
     params[:type] = type
     params[:visibility] = (public_ ? :public : :private)
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::StateMember, name, params))
     @cur
   end
 
   def define_valuebox(name, type)
     params = { :type => type }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Valuebox, name, params))
     @cur
   end
@@ -536,8 +532,8 @@ class Delegator
     params = {}
     params[:params] = params_
     params[:raises] = raises_
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Initializer, name, params))
     @cur
   end
@@ -546,8 +542,8 @@ class Delegator
     params = {}
     params[:params] = params_
     params[:raises] = raises_
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Finder, name, params))
     @cur
   end
@@ -636,8 +632,8 @@ class Delegator
 
   def define_const(_type, _name, _expression)
     params = { :type => _type, :expression => _expression }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Const, _name, params))
     @cur
   end
@@ -646,8 +642,8 @@ class Delegator
     params = Hash.new
     params[:oneway] = (_oneway == :oneway)
     params[:type]   = _type
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Operation, _name, params)
   end
@@ -655,14 +651,14 @@ class Delegator
     params = Hash.new
     params[:attribute] = _attribute
     params[:type] = _type
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Parameter, _name, params))
     @cur
   end
-  def declare_op_footer(_raises, _context)
+  def declare_op_footer(_raises, instantiation_context)
     @cur.raises = _raises || []
-    @cur.context = _context
+    @cur.context = instantiation_context
     if not @cur.context.nil?
       raise "context phrase's not supported"
     end
@@ -674,8 +670,8 @@ class Delegator
     params = Hash.new
     params[:type] = _type
     params[:readonly] = _readonly
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Attribute, _name, params))
   end
 
@@ -688,16 +684,16 @@ class Delegator
   end
   def define_struct(_name)
     params = { :forward => false }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Struct, _name, params)
   end
   def declare_member(_type, _name)
     params = Hash.new
     params[:type] = _type
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Member, _name, params))
     @cur
   end
@@ -710,8 +706,8 @@ class Delegator
   end
   def define_exception(_name)
     params = { :forward => false }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Exception, _name, params)
   end
@@ -731,23 +727,23 @@ class Delegator
   end
   def define_union(_name)
     params = { :forward => false }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Union, _name, params)
   end
   def define_union_switchtype(union_node, switchtype)
     union_node.set_switchtype(switchtype)
-    union_node.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
+    union_node.annotations.concat(@annotation_stack)
+    @annotation_stack = IDL::AST::Annotations.new
     union_node
   end
   def define_case(_labels, _type, _name)
     params = Hash.new
     params[:type] = _type
     params[:labels] = _labels
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::UnionMember, _name, params))
     @cur
   end
@@ -762,8 +758,8 @@ class Delegator
 
   def define_enum(_name)
     params = {}
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Enum, _name, params)
   end
@@ -773,8 +769,8 @@ class Delegator
       :value => n,
       :enum => @cur
     }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.enclosure.define(IDL::AST::Enumerator, _name, params))
     @cur
   end
@@ -788,8 +784,8 @@ class Delegator
   def declare_typedef(_type, _name)
     params = Hash.new
     params[:type] = _type
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Typedef, _name, params))
     @cur
   end

data/lib/ridl/expression.rb

@@ -21,7 +21,7 @@ module IDL
       false
     end
 
-    def instantiate(_context)
+    def instantiate(_)
       self
     end
 
@@ -47,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
@@ -104,8 +104,8 @@ 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)

data/lib/ridl/node.rb

@@ -48,9 +48,9 @@ module IDL::AST
   end
 
   class Annotations
-    def initialize(stack = [], index = {})
-      @index = index
-      @stack = stack
+    def initialize
+      @index = {}
+      @stack = []
     end
 
     def empty?
@@ -74,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
@@ -104,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
@@ -131,29 +121,26 @@ 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)
@@ -201,30 +188,26 @@ module IDL::AST
         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("/"),
+                self.scopes.collect{|s| s.name}.join("/"),
                 @repo_ver)
       else
         @repo_id
       end
     end
 
-    def has_annotations?()
+    def has_annotations?
       !@annotations.empty?
     end
 
@@ -237,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
@@ -352,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)
@@ -397,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,
@@ -408,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
@@ -449,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)
@@ -568,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)
@@ -647,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)
@@ -680,24 +664,27 @@ module IDL::AST
       false
     end
 
-    def self.concrete_param(_context, _node)
-      if _node.is_template?
-        _cnode = if _node.is_a?(IDL::AST::TemplateParam)
-          _node.concrete
+    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 "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,
@@ -725,7 +712,7 @@ 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 "missing template parameter for #{typename} #{scoped_lm_name}: #{_tp.name}" unless _ix < _module_instance.template_params.size
@@ -769,11 +756,11 @@ module IDL::AST
         else
           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
@@ -784,7 +771,6 @@ 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)
@@ -809,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
 
@@ -836,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
@@ -851,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
@@ -874,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?
@@ -882,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
 
@@ -961,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
@@ -994,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
@@ -1016,7 +997,7 @@ 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))
+          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
@@ -1121,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
 
@@ -1134,7 +1115,6 @@ module IDL::AST
   end # Interface
 
   class ComponentBase < Derivable
-    NAMETYPE = :class
     DEFINABLE = []
     attr_reader :base
     attr_reader :interfaces
@@ -1163,18 +1143,18 @@ 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))
+        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)
@@ -1290,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
@@ -1327,13 +1306,13 @@ 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)
@@ -1374,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)
@@ -1390,9 +1368,9 @@ 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
@@ -1404,7 +1382,7 @@ 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))
+        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
@@ -1453,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)
@@ -1471,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
@@ -1481,7 +1458,7 @@ 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))
+        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
@@ -1537,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)
@@ -1553,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'
@@ -1573,28 +1548,28 @@ module IDL::AST
       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)))
+              (@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))
+        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))
+        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?
@@ -1639,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)
@@ -1666,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
@@ -1732,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?,
@@ -1740,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
@@ -1945,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
@@ -1968,7 +1941,6 @@ module IDL::AST
   end # Eventtype
 
   class StateMember < Leaf
-    NAMETYPE = :member
     attr_reader :idltype, :visibility
     def initialize(_name, _enclosure, params)
       @is_recursive = false
@@ -2050,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)
@@ -2076,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)
@@ -2107,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
 
@@ -2138,7 +2109,6 @@ module IDL::AST
   end # Finder
 
   class Const < Leaf
-    NAMETYPE = :class
     attr_reader :idltype, :expression, :value
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
@@ -2169,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,
@@ -2225,17 +2194,16 @@ 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
@@ -2279,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,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
@@ -2352,7 +2320,6 @@ 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]
@@ -2388,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
 
@@ -2428,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)
@@ -2488,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
@@ -2514,7 +2480,6 @@ module IDL::AST
 
   class Member < Leaf
     attr_reader :idltype
-    NAMETYPE = :member
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @idltype  = params[:type]
@@ -2571,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
@@ -2679,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
@@ -2698,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)
@@ -2719,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)
@@ -2754,14 +2716,13 @@ 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)
@@ -2782,17 +2743,16 @@ module IDL::AST
       super(vars)
     end
 
-    def instantiate(_context, _enclosure)
+    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(_context, _enclosure, { :enum => _enum, :value => @value })
+      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]
@@ -2811,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