puppet 4.0.0 → 5.0.0

data/lib/puppet/parser/scope.rb

@@ -5,8 +5,8 @@ require 'forwardable'
 
 require 'puppet/parser'
 require 'puppet/parser/templatewrapper'
+require 'puppet/parser/resource'
 
-require 'puppet/resource/type_collection_helper'
 require 'puppet/util/methodhelper'
 
 # This class is part of the internal parser/evaluator/compiler functionality of Puppet.
@@ -18,29 +18,29 @@ class Puppet::Parser::Scope
   extend Forwardable
   include Puppet::Util::MethodHelper
 
-  include Puppet::Resource::TypeCollectionHelper
-  require 'puppet/parser/resource'
-
-  AST = Puppet::Parser::AST
-
   # Variables that always exist with nil value even if not set
   BUILT_IN_VARS = ['module_name'.freeze, 'caller_module_name'.freeze].freeze
+  EMPTY_HASH = {}.freeze
 
   Puppet::Util.logmethods(self)
 
   include Puppet::Util::Errors
   attr_accessor :source, :resource
-  attr_accessor :compiler
+  attr_reader :compiler
   attr_accessor :parent
-  attr_reader :namespaces
 
   # Hash of hashes of default values per type name
   attr_reader :defaults
 
-  # Add some alias methods that forward to the compiler, since we reference
-  # them frequently enough to justify the extra method call.
-  def_delegators :compiler, :catalog, :environment
+  # Alias for `compiler.environment`
+  def environment
+    @compiler.environment
+  end
 
+  # Alias for `compiler.catalog`
+  def catalog
+    @compiler.catalog
+  end
 
   # Abstract base class for LocalScope and MatchScope
   #
@@ -85,11 +85,8 @@ class Puppet::Parser::Scope
     end
 
     def [](name)
-      if @symbols.include?(name)
-        @symbols[name]
-      else
-        super
-      end
+      val = @symbols[name]
+      val.nil? && !@symbols.include?(name) ? super : val
     end
 
     def is_local_scope?
@@ -159,12 +156,12 @@ class Puppet::Parser::Scope
 
     def []=(name, value)
       # TODO: Bad choice of exception
-      raise Puppet::ParseError, "Numerical variables cannot be changed. Attempt to set $#{name}"
+      raise Puppet::ParseError, _("Numerical variables cannot be changed. Attempt to set $%{name}") % { name: name }
     end
 
     def delete(name)
       # TODO: Bad choice of exception
-      raise Puppet::ParseError, "Numerical variables cannot be deleted: Attempt to delete: $#{name}"
+      raise Puppet::ParseError, _("Numerical variables cannot be deleted: Attempt to delete: $%{name}") % { name: name }
     end
 
     def add_entries_to(target = {})
@@ -174,13 +171,113 @@ class Puppet::Parser::Scope
 
   end
 
+  # @api private
+  class ParameterScope < Ephemeral
+    class Access
+      attr_accessor :value
+
+      def assigned?
+        instance_variable_defined?(:@value)
+      end
+    end
+
+    # A parameter default must be evaluated using a special scope. The scope that is given to this method must
+    # have a `ParameterScope` as its last ephemeral scope. This method will then push a `MatchScope` while the
+    # given `expression` is evaluated. The method will catch any throw of `:unevaluated_parameter` and produce
+    # an error saying that the evaluated parameter X tries to access the unevaluated parameter Y.
+    #
+    # @param name [String] the name of the currently evaluated parameter
+    # @param expression [Puppet::Parser::AST] the expression to evaluate
+    # @param scope [Puppet::Parser::Scope] a scope where a `ParameterScope` has been pushed
+    # @return [Object] the result of the evaluation
+    #
+    # @api private
+    def evaluate3x(name, expression, scope)
+      scope.with_guarded_scope do
+        bad = catch(:unevaluated_parameter) do
+          scope.new_match_scope(nil)
+          return as_read_only { expression.safeevaluate(scope) }
+        end
+        parameter_reference_failure(name, bad)
+      end
+    end
+
+    def evaluate(name, expression, scope, evaluator)
+      scope.with_guarded_scope do
+        bad = catch(:unevaluated_parameter) do
+          scope.new_match_scope(nil)
+          return as_read_only { evaluator.evaluate(expression, scope) }
+        end
+        parameter_reference_failure(name, bad)
+      end
+    end
+
+    def parameter_reference_failure(from, to)
+      # Parameters are evaluated in the order they have in the @params hash.
+      keys = @params.keys
+      raise Puppet::Error, _("%{callee}: expects a value for parameter $%{to}") % { callee: @callee_name, to: to } if keys.index(to) < keys.index(from)
+      raise Puppet::Error, _("%{callee}: default expression for $%{from} tries to illegally access not yet evaluated $%{to}") % { callee: @callee_name, from: from, to: to }
+    end
+    private :parameter_reference_failure
+
+    def initialize(parent, callee_name, param_names)
+      super(parent)
+      @callee_name = callee_name
+      @params = {}
+      param_names.each { |name| @params[name] = Access.new }
+    end
+
+    def [](name)
+      access = @params[name]
+      return super if access.nil?
+      throw(:unevaluated_parameter, name) unless access.assigned?
+      access.value
+    end
+
+    def []=(name, value)
+      raise Puppet::Error, _("Attempt to assign variable %{name} when evaluating parameters") % { name: name } if @read_only
+      @params[name] ||= Access.new
+      @params[name].value = value
+    end
+
+    def bound?(name)
+      @params.include?(name)
+    end
+
+    def include?(name)
+      @params.include?(name) || super
+    end
+
+    def is_local_scope?
+      true
+    end
+
+    def as_read_only
+      read_only = @read_only
+      @read_only = true
+      begin
+        yield
+      ensure
+        @read_only = read_only
+      end
+    end
+
+    def to_hash
+      Hash[@params.select {|_, access| access.assigned? }.map { |name, access| [name, access.value] }]
+    end
+  end
+
+
   # Returns true if the variable of the given name has a non nil value.
   # TODO: This has vague semantics - does the variable exist or not?
   #       use ['name'] to get nil or value, and if nil check with exist?('name')
   #       this include? is only useful because of checking against the boolean value false.
   #
   def include?(name)
-    ! self[name].nil?
+    catch(:undefined_variable) {
+      return ! self[name].nil?
+    }
+    false
   end
 
   # Returns true if the variable of the given name is set to any value (including nil)
@@ -249,11 +346,11 @@ class Puppet::Parser::Scope
   end
 
   def find_hostclass(name)
-    known_resource_types.find_hostclass(name)
+    environment.known_resource_types.find_hostclass(name)
   end
 
   def find_definition(name)
-    known_resource_types.find_definition(name)
+    environment.known_resource_types.find_definition(name)
   end
 
   def find_global_scope()
@@ -272,24 +369,18 @@ class Puppet::Parser::Scope
     end
   end
 
-  # This just delegates directly.
-  def_delegator :compiler, :findresource
+  def findresource(type, title = nil)
+    @compiler.catalog.resource(type, title)
+  end
 
   # Initialize our new scope.  Defaults to having no parent.
-  def initialize(compiler, options = {})
+  def initialize(compiler, options = EMPTY_HASH)
     if compiler.is_a? Puppet::Parser::Compiler
-      self.compiler = compiler
+      @compiler = compiler
     else
       raise Puppet::DevError, "you must pass a compiler instance to a new scope object"
     end
 
-    if n = options.delete(:namespace)
-      @namespaces = [n.freeze].freeze
-    else
-      @namespaces = ["".freeze].freeze
-    end
-
-    raise Puppet::DevError, "compiler passed in options" if options.include? :compiler
     set_options(options)
 
     extend_with_functions_module
@@ -364,10 +455,22 @@ class Puppet::Parser::Scope
     values
   end
 
+  # Check if the given value is a known default for the given type
+  #
+  def is_default?(type, key, value)
+    defaults_for_type = @defaults[type]
+    unless defaults_for_type.nil?
+      default_param = defaults_for_type[key]
+      return true if !default_param.nil? && value == default_param.value
+    end
+    !parent.nil? && parent.is_default?(type, key, value)
+  end
+
   # Look up a defined type.
   def lookuptype(name)
     # This happens a lot, avoid making a call to make a call
-    known_resource_types.find_definition(name) || known_resource_types.find_hostclass(name)
+    krt = environment.known_resource_types
+    krt.find_definition(name) || krt.find_hostclass(name)
   end
 
   def undef_as(x,v)
@@ -383,45 +486,61 @@ class Puppet::Parser::Scope
   # manifest.
   #
   # @param [String] name the variable name to lookup
-  #
-  # @return Object the value of the variable, or nil if it's not found
+  # @param [Hash] hash of options, only internal code should give this
+  # @param [Boolean] if resolution is of the leaf of a qualified name - only internal code should give this
+  # @return Object the value of the variable, or if not found; nil if `strict_variables` is false, and thrown :undefined_variable otherwise
   #
   # @api public
-  def lookupvar(name, options = {})
+  def lookupvar(name, options = EMPTY_HASH)
     unless name.is_a? String
-      raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
+      raise Puppet::ParseError, _("Scope variable name %{name} is a %{klass}, not a string") % { name: name.inspect, klass: name.class }
     end
 
-    table = @ephemeral.last
+    # If name has '::' in it, it is resolved as a qualified variable
+    unless (idx = name.index('::')).nil?
+      # Always drop leading '::' if present as that is how the values are keyed.
+      return lookup_qualified_variable(idx == 0 ? name[2..-1] : name, options)
+    end
 
-    if name =~ /^(.*)::(.+)$/
-      class_name = $1
-      variable_name = $2
-      lookup_qualified_variable(class_name, variable_name, options)
+    # At this point, search is for a non qualified (simple) name
+    table = @ephemeral.last
+    val = table[name]
+    return val unless val.nil? && !table.include?(name)
 
-    # TODO: optimize with an assoc instead, this searches through scopes twice for a hit
-    elsif table.include?(name)
-      table[name]
+    next_scope = inherited_scope || enclosing_scope
+    if next_scope
+      next_scope.lookupvar(name, options)
     else
-      next_scope = inherited_scope || enclosing_scope
-      if next_scope
-        next_scope.lookupvar(name, options)
-      else
-        variable_not_found(name)
-      end
+      variable_not_found(name)
     end
   end
 
+  UNDEFINED_VARIABLES_KIND = 'undefined_variables'.freeze
+
+  # The exception raised when a throw is uncaught is different in different versions
+  # of ruby. In >=2.2.0 it is UncaughtThrowError (which did not exist prior to this)
+  #
+  UNCAUGHT_THROW_EXCEPTION = defined?(UncaughtThrowError) ? UncaughtThrowError : ArgumentError
+
   def variable_not_found(name, reason=nil)
-    # Built in variables always exist
-    if BUILT_IN_VARS.include?(name)
+    # Built in variables and numeric variables always exist
+    if BUILT_IN_VARS.include?(name) || name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       return nil
     end
-    if Puppet[:strict_variables]
-      throw :undefined_variable
-    else
-      nil
+    begin
+      throw(:undefined_variable, reason)
+    rescue  UNCAUGHT_THROW_EXCEPTION
+      case Puppet[:strict]
+      when :off
+        # do nothing
+      when :warning
+        Puppet.warn_once(UNDEFINED_VARIABLES_KIND, _("Variable: %{name}") % { name: name },
+        _("Undefined variable '%{name}'; %{reason}") % { name: name, reason: reason } )
+      when :error
+        raise ArgumentError, _("Undefined variable '%{name}'; %{reason}") % { name: name, reason: reason }
+      end
     end
+    nil
   end
 
   # Retrieves the variable value assigned to the name given as an argument. The name must be a String,
@@ -434,16 +553,15 @@ class Puppet::Parser::Scope
   # @see #[]=
   # @api public
   #
-  def [](varname, options={})
+  def [](varname, options = EMPTY_HASH)
     lookupvar(varname, options)
   end
 
-  # The scope of the inherited thing of this scope's resource. This could
-  # either be a node that was inherited or the class.
+  # The class scope of the inherited thing of this scope's resource.
   #
   # @return [Puppet::Parser::Scope] The scope or nil if there is not an inherited scope
   def inherited_scope
-    if has_inherited_class?
+    if resource && resource.type == TYPENAME_CLASS && !resource.resource_type.parent.nil?
       qualified_scope(resource.resource_type.parent)
     else
       nil
@@ -458,80 +576,77 @@ class Puppet::Parser::Scope
   #
   # @return [Puppet::Parser::Scope] The scope or nil if there is no enclosing scope
   def enclosing_scope
-    if has_enclosing_scope?
-      if parent.is_topscope? or parent.is_nodescope?
+     if has_enclosing_scope?
+      if parent.is_topscope? || parent.is_nodescope?
         parent
       else
         parent.enclosing_scope
       end
-    else
-      nil
-    end
+     end
   end
 
   def is_classscope?
-    resource and resource.type == "Class"
+    resource && resource.type == TYPENAME_CLASS
   end
 
   def is_nodescope?
-    resource and resource.type == "Node"
+    resource && resource.type == TYPENAME_NODE
   end
 
   def is_topscope?
-    compiler and self == compiler.topscope
+    equal?(@compiler.topscope)
   end
 
-  def lookup_qualified_variable(class_name, variable_name, position)
-    begin
-      if lookup_as_local_name?(class_name, variable_name)
-        self[variable_name]
-      else
-        qualified_scope(class_name).lookupvar(variable_name, position)
-      end
-    rescue RuntimeError => e
-      unless Puppet[:strict_variables]
-        # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
-        location = if position[:lineproc]
-                     " at #{position[:lineproc].call}"
-                   elsif position[:file] && position[:line]
-                     " at #{position[:file]}:#{position[:line]}"
-                   else
-                     ""
-                   end
-        warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{e.message}#{location}"
+  # @api private
+  def lookup_qualified_variable(fqn, options)
+    table = @compiler.qualified_variables
+    val = table[fqn]
+    return val if !val.nil? || table.include?(fqn)
+
+    # not found - search inherited scope for class
+    leaf_index = fqn.rindex('::')
+    unless leaf_index.nil?
+      leaf_name = fqn[ (leaf_index+2)..-1 ]
+      class_name = fqn[ 0, leaf_index ]
+      begin
+        qs = qualified_scope(class_name)
+        unless qs.nil?
+          iscope = qs.inherited_scope
+          return lookup_qualified_variable("#{iscope.source.name}::#{leaf_name}", options) unless iscope.nil?
+        end
+      rescue RuntimeError => e
+        # because a failure to find the class, or inherited should be reported against given name
+        return handle_not_found(class_name, leaf_name, options, e.message)
       end
-      variable_not_found("#{class_name}::#{variable_name}", e.message)
     end
+    # report with leading '::' by using empty class_name
+    return handle_not_found('', fqn, options)
   end
 
-  # Handles the special case of looking up fully qualified variable in not yet evaluated top scope
-  # This is ok if the lookup request originated in topscope (this happens when evaluating
-  # bindings; using the top scope to provide the values for facts.
-  # @param class_name [String] the classname part of a variable name, may be special ""
-  # @param variable_name [String] the variable name without the absolute leading '::'
-  # @return [Boolean] true if the given variable name should be looked up directly in this scope
-  #
-  def lookup_as_local_name?(class_name, variable_name)
-    # not a local if name has more than one segment
-    return nil if variable_name =~ /::/
-    # partial only if the class for "" cannot be found
-    return nil unless class_name == "" && klass = find_hostclass(class_name) && class_scope(klass).nil?
-    is_topscope?
-  end
-
-  def has_inherited_class?
-    is_classscope? and resource.resource_type.parent
+  def handle_not_found(class_name, variable_name, position, reason = nil)
+    unless Puppet[:strict_variables]
+      # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
+      location = if position[:lineproc]
+                   " at #{position[:lineproc].call}"
+                 elsif position[:file] && position[:line]
+                   " at #{position[:file]}:#{position[:line]}"
+                 else
+                   ""
+                 end
+      variable_not_found("#{class_name}::#{variable_name}", "#{reason}#{location}")
+      return nil
+    end
+    variable_not_found("#{class_name}::#{variable_name}", reason)
   end
-  private :has_inherited_class?
 
   def has_enclosing_scope?
-    not parent.nil?
+    ! parent.nil?
   end
   private :has_enclosing_scope?
 
   def qualified_scope(classname)
-    raise "class #{classname} could not be found"     unless klass = find_hostclass(classname)
-    raise "class #{classname} has not been evaluated" unless kscope = class_scope(klass)
+    raise _("class %{classname} could not be found") % { classname: classname }     unless klass = find_hostclass(classname)
+    raise _("class %{classname} has not been evaluated") % { classname: classname } unless kscope = class_scope(klass)
     kscope
   end
   private :qualified_scope
@@ -555,18 +670,13 @@ class Puppet::Parser::Scope
     target
   end
 
-  def namespaces
-    @namespaces
-  end
-
   # Create a new scope and set these options.
   def newscope(options = {})
     compiler.newscope(self, options)
   end
 
   def parent_module_name
-    return nil unless @parent
-    return nil unless @parent.source
+    return nil unless @parent && @parent.source
     @parent.source.module_name
   end
 
@@ -581,49 +691,102 @@ class Puppet::Parser::Scope
 
     params.each { |param|
       if table.include?(param.name)
-        raise Puppet::ParseError.new("Default already defined for #{type} { #{param.name} }; cannot redefine", param.line, param.file)
+        raise Puppet::ParseError.new(_("Default already defined for %{type} { %{param} }; cannot redefine") % { type: type, param: param.name }, param.file, param.line)
       end
       table[param.name] = param
     }
   end
 
-  RESERVED_VARIABLE_NAMES = ['trusted', 'facts'].freeze
+  # Merge all settings for the given _env_name_ into this scope
+  # @param env_name [Symbol] the name of the environment
+  def merge_settings(env_name)
+    settings = Puppet.settings
+    table = effective_symtable(false)
+    global_table = compiler.qualified_variables
+    all_local = {}
+    settings.each_key do |name|
+      next if :name == name
+      key = name.to_s
+      value = transform_setting(settings.value_sym(name, env_name))
+      table[key] = value
+      all_local[key] = value
+      # also write the fqn into global table for direct lookup
+      global_table["settings::#{key}"] = value
+    end
+    # set the 'all_local' - a hash of all settings
+    global_table["settings::all_local"] = all_local
+    nil
+  end
+
+  def transform_setting(val)
+    if val.is_a?(String) || val.is_a?(Numeric) || true == val || false == val || nil == val
+      val
+    elsif val.is_a?(Array)
+      val.map {|entry| transform_setting(entry) }
+    elsif val.is_a?(Hash)
+      result = {}
+      val.each {|k,v| result[transform_setting(k)] = transform_setting(v) }
+      result
+    else
+      # not ideal, but required as there are settings values that are special
+      :undef == val ? nil : val.to_s
+    end
+  end
+  private :transform_setting
+
+  VARNAME_TRUSTED = 'trusted'.freeze
+  VARNAME_FACTS = 'facts'.freeze
+  VARNAME_SERVER_FACTS = 'server_facts'.freeze
+  RESERVED_VARIABLE_NAMES = [VARNAME_TRUSTED, VARNAME_FACTS].freeze
+  TYPENAME_CLASS = 'Class'.freeze
+  TYPENAME_NODE = 'Node'.freeze
 
   # Set a variable in the current scope.  This will override settings
   # in scopes above, but will not allow variables in the current scope
   # to be reassigned.
   #   It's preferred that you use self[]= instead of this; only use this
   # when you need to set options.
-  def setvar(name, value, options = {})
+  def setvar(name, value, options = EMPTY_HASH)
     if name =~ /^[0-9]+$/
-      raise Puppet::ParseError.new("Cannot assign to a numeric match result variable '$#{name}'") # unless options[:ephemeral]
+      raise Puppet::ParseError.new(_("Cannot assign to a numeric match result variable '$%{name}'") % { name: name }) # unless options[:ephemeral]
     end
     unless name.is_a? String
-      raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
+      raise Puppet::ParseError, _("Scope variable name %{value0} is a %{value1}, not a string") % { value0: name.inspect, value1: name.class }
     end
 
     # Check for reserved variable names
-    if !options[:privileged] && RESERVED_VARIABLE_NAMES.include?(name)
-      raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
+    if (name == VARNAME_TRUSTED || name == VARNAME_FACTS) && !options[:privileged]
+      raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name }
+    end
+
+    # Check for server_facts reserved variable name if the trusted_sever_facts setting is true
+    if name == VARNAME_SERVER_FACTS && !options[:privileged] && Puppet[:trusted_server_facts]
+      raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name }
     end
 
     table = effective_symtable(options[:ephemeral])
     if table.bound?(name)
-      if options[:append]
-        error = Puppet::ParseError.new("Cannot append, variable #{name} is defined in this scope")
-      else
-        error = Puppet::ParseError.new("Cannot reassign variable #{name}")
-      end
+      error = Puppet::ParseError.new(_("Cannot reassign variable '$%{name}'") % { name: name })
       error.file = options[:file] if options[:file]
       error.line = options[:line] if options[:line]
       raise error
     end
 
-    if options[:append]
-      # produced result (value) is the resulting appended value, note: the table[]= does not return the value
-      table[name] = (value = append_value(undef_as('', self[name]), value))
-    else
-      table[name] = value
+    table[name] = value
+
+    # Assign the qualified name in the environment
+    # Note that Settings scope has a source set to Boolean true.
+    #
+    # Only meaningful to set a fqn globally if table to assign to is the top of the scope's ephemeral stack
+    if @symtable.equal?(table)
+      if is_topscope?
+        # the scope name is '::'
+        compiler.qualified_variables[name] = value
+      elsif source.is_a?(Puppet::Resource::Type) && source.type == :hostclass
+        # the name is the name of the class
+        sourcename = source.name
+        compiler.qualified_variables["#{sourcename}::#{name}"] = value
+      end
     end
     value
   end
@@ -636,6 +799,10 @@ class Puppet::Parser::Scope
     setvar('facts', deep_freeze(hash), :privileged => true)
   end
 
+  def set_server_facts(hash)
+    setvar('server_facts', deep_freeze(hash), :privileged => true)
+  end
+
   # Deeply freezes the given object. The object and its content must be of the types:
   # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
   # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
@@ -653,7 +820,7 @@ class Puppet::Parser::Scope
     when String
       object.freeze
     else
-      raise Puppet::Error, "Unsupported data type: '#{object.class}'"
+      raise Puppet::Error, _("Unsupported data type: '%{klass}'") % { klass: object.class }
     end
     object
   end
@@ -666,15 +833,13 @@ class Puppet::Parser::Scope
   #
   # @param use_ephemeral [Boolean] whether the top most ephemeral (of any kind) should be used or not
   def effective_symtable(use_ephemeral)
-    s = @ephemeral.last
-    if use_ephemeral
-      return s || @symtable
-    else
-      while s && !s.is_local_scope?()
-        s = s.parent
-      end
-      s || @symtable
+    s = @ephemeral[-1]
+    return s || @symtable if use_ephemeral
+
+    while s && !s.is_local_scope?()
+      s = s.parent
     end
+    s || @symtable
   end
 
   # Sets the variable value of the name given as an argument to the given value. The value is
@@ -684,46 +849,35 @@ class Puppet::Parser::Scope
   #
   # @param varname [String] The variable name to which the value is assigned. Must not contain `::`
   # @param value [String] The value to assign to the given variable name.
-  # @param options [Hash] Additional options, not part of api.
+  # @param options [Hash] Additional options, not part of api and no longer used.
   #
   # @api public
   #
-  def []=(varname, value, options = {})
-    setvar(varname, value, options = {})
-  end
-
-  def append_value(bound_value, new_value)
-    case new_value
-    when Array
-      bound_value + new_value
-    when Hash
-      bound_value.merge(new_value)
-    else
-      if bound_value.is_a?(Hash)
-        raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported"
-      end
-      bound_value + new_value
-    end
+  def []=(varname, value, _ = nil)
+    setvar(varname, value)
   end
-  private :append_value
-
-  # Return the tags associated with this scope.
-  def_delegator :resource, :tags
 
   # Used mainly for logging
   def to_s
     "Scope(#{@resource})"
   end
 
-  # remove ephemeral scope up to level
-  # TODO: Who uses :all ? Remove ??
+  alias_method :inspect, :to_s
+
+  # Pop ephemeral scopes up to level and return them
   #
-  def unset_ephemeral_var(level=:all)
-    if level == :all
-      @ephemeral = [ MatchScope.new(@symtable, nil)]
-    else
-      @ephemeral.pop(@ephemeral.size - level)
-    end
+  # @param level [Integer] a positive integer
+  # @return [Array] the removed ephemeral scopes
+  # @api private
+  def pop_ephemerals(level)
+    @ephemeral.pop(@ephemeral.size - level)
+  end
+
+  # Push ephemeral scopes onto the ephemeral scope stack
+  # @param ephemeral_scopes [Array]
+  # @api private
+  def push_ephemerals(ephemeral_scopes)
+    ephemeral_scopes.each { |ephemeral_scope| @ephemeral.push(ephemeral_scope) } unless ephemeral_scopes.nil?
   end
 
   def ephemeral_level
@@ -739,6 +893,69 @@ class Puppet::Parser::Scope
     end
   end
 
+  # Execute given block in global scope with no ephemerals present
+  #
+  # @yieldparam [Scope] global_scope the global and ephemeral less scope
+  # @return [Object] the return of the block
+  #
+  # @api private
+  def with_global_scope(&block)
+    find_global_scope.without_ephemeral_scopes(&block)
+  end
+
+  # Execute given block with a ephemeral scope containing the given variables
+  # @api private
+  def with_local_scope(scope_variables)
+    local = LocalScope.new(@ephemeral.last)
+    scope_variables.each_pair { |k, v| local[k] = v }
+    @ephemeral.push(local)
+    begin
+      yield(self)
+    ensure
+      @ephemeral.pop
+    end
+  end
+
+  # Execute given block with all ephemeral popped from the ephemeral stack
+  #
+  # @api private
+  def without_ephemeral_scopes
+    save_ephemeral = @ephemeral
+    begin
+      @ephemeral = [ @symtable ]
+      yield(self)
+    ensure
+      @ephemeral = save_ephemeral
+    end
+  end
+
+  # Nests a parameter scope
+  # @param [String] callee_name the name of the function, template, or resource that defines the parameters
+  # @param [Array<String>] param_names list of parameter names
+  # @yieldparam [ParameterScope] param_scope the nested scope
+  # @api private
+  def with_parameter_scope(callee_name, param_names)
+    param_scope = ParameterScope.new(@ephemeral.last, callee_name, param_names)
+    with_guarded_scope do
+      @ephemeral.push(param_scope)
+      yield(param_scope)
+    end
+  end
+
+  # Execute given block and ensure that ephemeral level is restored
+  #
+  # @return [Object] the return of the block
+  #
+  # @api private
+  def with_guarded_scope
+    elevel = ephemeral_level
+    begin
+      yield
+    ensure
+      pop_ephemerals(elevel)
+    end
+  end
+
   # Sets match data in the most nested scope (which always is a MatchScope), it clobbers match data already set there
   #
   def set_match_data(match_data)
@@ -757,28 +974,29 @@ class Puppet::Parser::Scope
       new_ephemeral(true)
       match.each {|k,v| setvar(k, v, :file => file, :line => line, :ephemeral => true) }
       # Must always have an inner match data scope (that starts out as transparent)
-      # In 3x slightly wasteful, since a new nested scope is created for a match 
+      # In 3x slightly wasteful, since a new nested scope is created for a match
       # (TODO: Fix that problem)
       new_ephemeral(false)
     else
-      raise(ArgumentError,"Invalid regex match data. Got a #{match.class}") unless match.is_a?(MatchData)
+      raise(ArgumentError,_("Invalid regex match data. Got a %{klass}") % { klass: match.class }) unless match.is_a?(MatchData)
       # Create a match ephemeral and set values from match data
       new_match_scope(match)
     end
   end
 
+  # @api private
   def find_resource_type(type)
-    # It still works fine without the type == 'class' short-cut, but it is a lot slower.
-    return nil if ["class", "node"].include? type.to_s.downcase
-    find_builtin_resource_type(type) || find_defined_resource_type(type)
+    raise Puppet::DevError, "Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
+  # @api private
   def find_builtin_resource_type(type)
-    Puppet::Type.type(type.to_s.downcase.to_sym)
+    raise Puppet::DevError, "Scope#find_builtin_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
+  # @api private
   def find_defined_resource_type(type)
-    known_resource_types.find_definition(type.to_s.downcase)
+    raise Puppet::DevError, "Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
 
@@ -796,25 +1014,10 @@ class Puppet::Parser::Scope
     end
   end
 
+  # To be removed when enough time has passed after puppet 5.0.0
+  # @api private
   def resolve_type_and_titles(type, titles)
-    raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
-
-    case type.downcase
-    when "class"
-      # resolve the titles
-      titles = titles.collect do |a_title|
-        hostclass = find_hostclass(a_title)
-        hostclass ?  hostclass.name : a_title
-      end
-    when "node"
-      # no-op
-    else
-      # resolve the type
-      resource_type = find_resource_type(type)
-      type = resource_type.name if resource_type
-    end
-
-    return [type, titles]
+    raise Puppet::DevError, "Scope#resolve_type_and_title() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
   # Transforms references to classes to the form suitable for
@@ -841,27 +1044,43 @@ class Puppet::Parser::Scope
         name.title.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Pops::Types::PHostClassType
-        raise ArgumentError, "Cannot use an unspecific Class[] Type" unless name.class_name
+        #TRANSLATORS "Class" and "Type" are Puppet keywords and should not be translated
+        raise ArgumentError, _("Cannot use an unspecific Class[] Type") unless name.class_name
         name.class_name.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Pops::Types::PResourceType
         assert_class_and_title(name.type_name, name.title)
         name.title.sub(/^([^:]{1,2})/, '::\1')
-      end
+      end.downcase
     end
   end
 
+  # Calls a 3.x or 4.x function by name with arguments given in an array using the 4.x calling convention
+  # and returns the result.
+  # Note that it is the caller's responsibility to rescue the given ArgumentError and provide location information
+  # to aid the user find the problem. The problem is otherwise reported against the source location that
+  # invoked the function that ultimately called this method.
+  #
+  # @return [Object] the result of the called function
+  # @raise ArgumentError if the function does not exist
+  def call_function(func_name, args, &block)
+    Puppet::Pops::Parser::EvaluatingParser.new.evaluator.external_call_function(func_name, args, self, &block)
+  end
+
   private
 
   def assert_class_and_title(type_name, title)
     if type_name.nil? || type_name == ''
-      raise ArgumentError, "Cannot use an unspecific Resource[] where a Resource['class', name] is expected"
+      #TRANSLATORS "Resource" is a class name and should not be translated
+      raise ArgumentError, _("Cannot use an unspecific Resource[] where a Resource['class', name] is expected")
     end
     unless type_name =~ /^[Cc]lass$/
-      raise ArgumentError, "Cannot use a Resource[#{type_name}] where a Resource['class', name] is expected"
+      #TRANSLATORS "Resource" is a class name and should not be translated
+      raise ArgumentError, _("Cannot use a Resource[%{type_name}] where a Resource['class', name] is expected") % { type_name: type_name }
     end
     if title.nil?
-      raise ArgumentError, "Cannot use an unspecific Resource['class'] where a Resource['class', name] is expected"
+      #TRANSLATORS "Resource" is a class name and should not be translated
+      raise ArgumentError, _("Cannot use an unspecific Resource['class'] where a Resource['class', name] is expected")
     end
   end