puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -404,7 +404,7 @@ class EvaluatorImpl
     end
 
     left_o = bin_expr.left_expr
-    if left.is_a?(URI) && operator == '+'
+    if (left.is_a?(URI) || left.is_a?(Types::PBinaryType::Binary)) && operator == '+'
       concatenate(left, right)
     elsif (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
@@ -873,6 +873,18 @@ class EvaluatorImpl
     evaluated_resources
   end
 
+  def eval_ApplyExpression(o, scope)
+    # All expressions are wrapped in an ApplyBlockExpression so we can identify the contents of
+    # that block. However we don't want to serialize the block expression, so unwrap here.
+    body = if o.body.statements.count > 1
+      Model::BlockExpression.from_asserted_hash(o.body._pcore_init_hash)
+    else
+      o.body.statements[0]
+    end
+
+    Puppet.lookup(:apply_executor).apply(unfold([], o.arguments, scope), body, scope)
+  end
+
   # Produces 3x parameter
   def eval_AttributeOperation(o, scope)
     create_resource_parameter(o, scope, o.attribute_name, evaluate(o.value_expr, scope), o.operator)
@@ -947,7 +959,7 @@ class EvaluatorImpl
     name = name.value # the string function name
 
     obj = receiver[0]
-    receiver_type = Types::TypeCalculator.infer_callable_methods_t(obj)
+    receiver_type = Types::TypeCalculator.infer(obj)
     if receiver_type.is_a?(Types::TypeWithMembers)
       member = receiver_type[name]
       unless member.nil?
@@ -1209,6 +1221,9 @@ class EvaluatorImpl
     when URI
       raise ArgumentError.new(_('An URI can only be merged with an URI or String')) unless y.is_a?(String) || y.is_a?(URI)
       x + y
+    when Types::PBinaryType::Binary
+      raise ArgumentError.new(_('Can only append Binary to a Binary')) unless y.is_a?(Types::PBinaryType::Binary)
+      Types::PBinaryType::Binary.from_binary_string(x.binary_buffer + y.binary_buffer)
     else
       concatenate([x], y)
     end

data/lib/puppet/pops/evaluator/external_syntax_support.rb

@@ -35,11 +35,10 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
   def lookup_keys_for_syntax(syntax)
     segments = syntax.split(/\+/)
     result = []
-    loop do
+    begin
       result << segments.join("+")
       segments.shift
-      break if segments.empty?
-    end
+    end until segments.empty?
     result
   end
 

data/lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -61,7 +61,7 @@ class Runtime3Converter
   end
 
   def convert_NilClass(o, scope, undef_value)
-    @inner ? :undef : undef_value
+    @inner ? nil : undef_value
   end
 
   def convert_Integer(o, scope, undef_value)
@@ -78,8 +78,10 @@ class Runtime3Converter
   end
 
   def convert_String(o, scope, undef_value)
-    # although wasteful, needed because user code may mutate these strings in Resources
-    o.frozen? ? o.dup : o
+    # Although wasteful, a dup is needed because user code may mutate these strings when applying
+    # Resources. This does not happen when in master mode since it only uses Resources that are
+    # in puppet core and those are all safe.
+    o.frozen? && !Puppet.run_mode.master? ? o.dup : o
   end
 
   def convert_Object(o, scope, undef_value)
@@ -103,7 +105,8 @@ class Runtime3Converter
   end
 
   def convert_Symbol(o, scope, undef_value)
-    o == :undef && !@inner ? undef_value : o
+    o == :undef ? undef_value : o
+    #o == :undef && !@inner ? undef_value : o
   end
 
   def convert_PAnyType(o, scope, undef_value)
@@ -196,6 +199,22 @@ class Runtime3FunctionArgumentConverter < Runtime3Converter
     o.to_s
   end
 
+  # Converts result back to 4.x by replacing :undef with nil in Array and Hash objects
+  #
+  def self.convert_return(val3x)
+    if val3x == :undef
+      nil
+    elsif val3x.is_a?(Array)
+      val3x.map {|v| convert_return(v) }
+    elsif val3x.is_a?(Hash)
+      hsh = {}
+      val3x.each_pair {|k,v| hsh[convert_return(k)] = convert_return(v)}
+      hsh
+    else
+      val3x
+    end
+  end
+
   @instance = self.new
 end
 

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -33,7 +33,7 @@ module Runtime3Support
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def optionally_fail(issue, semantic, options={}, except=nil)
-    if except.nil? && diagnostic_producer.severity_producer[issue] == :error
+    if except.nil?
       # Want a stacktrace, and it must be passed as an exception
       begin
        raise EvaluationError.new()
@@ -299,21 +299,20 @@ module Runtime3Support
     # 'ruby -wc' thinks that _func is unused, because the only reference to it
     # is inside of the Kernel.eval string below. By prefixing it with the
     # underscore, we let Ruby know to not worry about whether it's unused or not.
-    if loader && func = loader.load(:function, name)
+    if loader && _func = loader.load(:function, name)
       Puppet::Util::Profiler.profile(name, [:functions, name]) do
-        # Add stack frame when calling.
-        return Puppet::Pops::PuppetStack.stack(file || '', line, func, :call, [scope, *args], &block)
+        # Add stack frame when calling. See Puppet::Pops::PuppetStack
+        return Kernel.eval('_func.call(scope, *args, &block)'.freeze, Kernel.binding, file || '', line)
       end
     end
-    # Call via 3x API if function exists there
+    # Call via 3x API if function exists there without having been autoloaded
     fail(Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
     mapped_args = Runtime3FunctionArgumentConverter.map_args(args, scope, '')
-    result = Puppet::Pops::PuppetStack.stack(file, line, scope, "function_#{name}", [mapped_args], &block)
-    # Prevent non r-value functions from leaking their result (they are not written to care about this)
-    Puppet::Parser::Functions.rvalue?(name) ? result : nil
+    # The 3x function performs return value mapping and returns nil if it is not of rvalue type
+    Puppet::Pops::PuppetStack.stack(file, line, scope, "function_#{name}", [mapped_args], &block)
   end
 
   # The o is used for source reference

data/lib/puppet/pops/functions/dispatch.rb

@@ -79,6 +79,12 @@ class Dispatch < Evaluator::CallableSignature
               scope
             when :pal_script_compiler
               Puppet.lookup(:pal_script_compiler)
+            when :cache
+              Puppet::Pops::Adapters::ObjectIdCacheAdapter.adapt(scope.compiler)
+            when :pal_catalog_compiler
+              Puppet.lookup(:pal_catalog_compiler)
+            when :pal_compiler
+              Puppet.lookup(:pal_compiler)
             else
               raise ArgumentError, _("Unknown injection %{injection_name}") % { injection_name: injection_name }
             end

data/lib/puppet/pops/issues.rb

@@ -286,7 +286,7 @@ module Issues
   end
 
   ILLEGAL_NAME = hard_issue :ILLEGAL_NAME, :name do
-    _("Illegal name. The given name '%{name}' does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\\w*)*$/") % { name: name }
+    _("Illegal name. The given name '%{name}' does not conform to the naming rule /^((::)?[a-z_]\\w*)(::[a-z]\\w*)*$/") % { name: name }
   end
 
   ILLEGAL_SINGLE_TYPE_MAPPING = hard_issue :ILLEGAL_TYPE_MAPPING, :expression do
@@ -760,10 +760,6 @@ module Issues
     _("An escape char for @() may only appear once. Got '%{escapes}'") % { escapes: escapes.join(', ') }
   end
 
-  HEREDOC_DIRTY_MARGIN = hard_issue :HEREDOC_DIRTY_MARGIN, :heredoc_line do
-    _("Heredoc with text in the margin is not allowed (line %{heredoc_line} in this heredoc)") % { heredoc_line: heredoc_line }
-  end
-
   ILLEGAL_BOM = hard_issue :ILLEGAL_BOM, :format_name, :bytes do
     _("Illegal %{format} Byte Order mark at beginning of input: %{bom} - remove these from the puppet source") % { format: format_name, bom: bytes }
   end
@@ -898,10 +894,18 @@ module Issues
     _("The catalog operation '%{operation}' is only available when compiling a catalog") % { operation: operation }
   end
 
+  EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING = issue :EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING, :klass do
+    _("%{expr} is only available when compiling a catalog") % { expr: label.a_an_uc(klass) }
+  end
+
   TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING = issue :TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, :operation do
     _("The task operation '%{operation}' is not available when compiling a catalog") % { operation: operation }
   end
 
+  EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING = issue :EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, :klass do
+    _("%{expr} is not available when compiling a catalog") % { expr: label.a_an_uc(klass) }
+  end
+
   TASK_MISSING_BOLT = issue :TASK_MISSING_BOLT, :action do
     _("The 'bolt' library is required to %{action}") % { action: action }
   end
@@ -913,10 +917,5 @@ module Issues
   LOADER_FAILURE = issue :LOADER_FAILURE, :type do
     _('Failed to load: %{type_name}') % { type: type }
   end
-
-  DEPRECATED_APP_ORCHESTRATION = issue :DEPRECATED_APP_ORCHESTRATION, :klass do
-    _("Use of the application-orchestration %{expr} is deprecated. See https://puppet.com/docs/puppet/5.5/deprecated_language.html" % { expr: label(klass) })
-  end
-
 end
 end

data/lib/puppet/pops/loader/loader.rb

@@ -29,7 +29,7 @@ class Loader
   attr_reader :loader_name
 
   # Describes the kinds of things that loaders can load
-  LOADABLE_KINDS = [:func_4x, :func_4xpp, :datatype, :type_pp, :resource_type_pp, :plan, :task].freeze
+  LOADABLE_KINDS = [:func_4x, :func_4xpp, :func_3x, :datatype, :type_pp, :resource_type_pp, :plan, :task].freeze
 
   # @param [String] name the name of the loader. Must be unique among all loaders maintained by a {Loader} instance
   def initialize(loader_name)

data/lib/puppet/pops/loader/loader_paths.rb

@@ -25,7 +25,9 @@ module LoaderPaths
         if loader.loadables.include?(:func_4xpp)
           result << FunctionPathPP.new(loader)
         end
-        # When wanted also add FunctionPath3x to load 3x functions
+        if loader.loadables.include?(:func_3x)
+          result << FunctionPath3x.new(loader)
+        end
     when :plan
       result << PlanPathPP.new(loader)
     when :task
@@ -67,7 +69,7 @@ module LoaderPaths
       @generic_path = (the_root_path.nil? ? relative_path : File.join(the_root_path, relative_path))
     end
 
-    def match_many?
+    def fuzzy_matching?
       false
     end
 
@@ -239,7 +241,7 @@ module LoaderPaths
       EMPTY_STRING
     end
 
-    def match_many?
+    def fuzzy_matching?
       true
     end
 

data/lib/puppet/pops/loader/module_loaders.rb

@@ -19,6 +19,24 @@ module Loader
 # @api private
 #
 module ModuleLoaders
+
+  # Wildcard module name for module loaders, makes loading possible from any namespace.
+  NAMESPACE_WILDCARD = '*'.freeze
+
+  # This is exactly the same as the #system_loader_from method, but the argument for path is changed to
+  # location where pluginsync stores functions. It also accepts definitions in any namespace since pluginsync
+  # places all of them in the same directory.
+  #
+  def self.cached_loader_from(parent_loader, loaders)
+    LibRootedFileBased.new(parent_loader,
+      loaders,
+      NAMESPACE_WILDCARD,
+      Puppet[:libdir],
+      'cached_puppet_lib',
+      [:func_4x, :datatype]
+    )
+  end
+
   def self.system_loader_from(parent_loader, loaders)
     # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
     # The only way to find this across the different ways puppet can be installed is
@@ -31,7 +49,7 @@ module ModuleLoaders
                                                        nil,
                                                        puppet_lib,   # may or may not have a 'lib' above 'puppet'
                                                        'puppet_system',
-                                                        [:func_4x, :datatype]   # only load ruby functions and types from "puppet"
+                                                        [:func_4x, :func_3x, :datatype]   # only load ruby functions and types from "puppet"
                                                        )
   end
 
@@ -82,9 +100,10 @@ module ModuleLoaders
 
   class AbstractPathBasedModuleLoader < BaseLoader
 
-    # The name of the module, or nil, if this is a global "component"
+    # The name of the module, or nil, if this is a global "component", or "any module" if set to the `NAMESPACE_WILDCARD` (*)
     attr_reader :module_name
 
+
     # The path to the location of the module/component - semantics determined by subclass
     attr_reader :path
 
@@ -169,10 +188,12 @@ module ModuleLoaders
         # The name is in a name space.
 
         # Then entity cannot possible be in this module unless the name starts with the module name.
-        # Note: If "module" represents a "global component", the module_name is nil and cannot match which is
-        # ok since such a "module" cannot have namespaced content).
+        # Note:
+        # * If "module" represents a "global component", the module_name is nil and cannot match which is
+        #   ok since such a "module" cannot have namespaced content).
+        # * If this loader is allowed to have namespaced content, the module_name can be set to NAMESPACE_WILDCARD `*`
         #
-        return nil unless name_parts[0] == module_name
+        return nil unless name_parts[0] == module_name || module_name == NAMESPACE_WILDCARD
       else
         # The name is in the global name space.
 
@@ -203,7 +224,7 @@ module ModuleLoaders
         when :type
           if !global?
             # Global name must be the name of the module
-            unless name_parts[0] == module_name
+            unless name_parts[0] == module_name || module_name == NAMESPACE_WILDCARD
               # Check for ruby defined data type in global namespace before giving up
               origin, smart_path = find_existing_path(typed_name)
               return smart_path.is_a?(LoaderPaths::DataTypePath) ? instantiate(smart_path, typed_name, origin) : nil
@@ -219,9 +240,9 @@ module ModuleLoaders
               return set_entry(typed_name, value, origin)
             end
 
-            #TRANSLATORS 'TypeSet' should not be translated
+            # TRANSLATORS 'TypeSet' should not be translated
             raise ArgumentError, _("The code loaded from %{origin} does not define the TypeSet '%{module_name}'") %
-                { origin: origin, module_name: module_name.capitalize }
+                { origin: origin, module_name: name_parts[0].capitalize }
           end
         else
           # anything else cannot possibly be in this module
@@ -291,13 +312,12 @@ module ModuleLoaders
       raise NotImplementedError.new
     end
 
-    # Abstract method that subclasses override to return an array of paths that match the resolved path regardless of
-    # path extension.
+    # Abstract method that subclasses override to return an array of paths that may be associated with the resolved path.
     #
     # @param resolved_path [String] a path, without extension, resolved by a smart path against the loader's root (if it has one)
     # @return [Array<String>]
     #
-    def existing_paths(resolved_path)
+    def candidate_paths(resolved_path)
       raise NotImplementedError.new
     end
 
@@ -326,7 +346,7 @@ module ModuleLoaders
     # @return [Boolean] `true` if this loader represents a global component
     #
     def global?
-      module_name.nil? || module_name == ENVIRONMENT
+      module_name.nil? || module_name == NAMESPACE_WILDCARD || module_name == ENVIRONMENT
     end
 
     # Answers `true` if the loader used by this instance is rooted beneath 'lib'. This is
@@ -386,9 +406,9 @@ module ModuleLoaders
         next unless sp.valid_name?(typed_name)
         origin = sp.effective_path(typed_name, is_global ? 0 : 1)
         unless origin.nil?
-          if sp.match_many?
-            # Find all paths that starts with origin
-            origins = existing_paths(origin)
+          if sp.fuzzy_matching?
+            # Find all paths that might be related to origin
+            origins = candidate_paths(origin)
             return [origins, sp] unless origins.empty?
           else
             existing = existing_path(origin)
@@ -424,13 +444,19 @@ module ModuleLoaders
       @path_index.include?(effective_path) ? effective_path : nil
     end
 
-    def existing_paths(effective_path)
+    def candidate_paths(effective_path)
+      basename = File.basename(effective_path, '.*')
       dirname = File.dirname(effective_path)
-      basename = File.basename(effective_path)
-      # Select all paths matching `effective_path` up until an optional file extension
-      @path_index.select do |path|
-        File.basename(path, '.*') == basename &&
-          File.dirname(path) == dirname
+
+      files = @path_index.select do |path|
+        File.dirname(path) == dirname
+      end
+
+      # At least one file has to match what we're loading, or it certainly doesn't exist
+      if files.any? { |file| File.basename(file, '.*') == basename }
+        files
+      else
+        []
       end
     end
 

data/lib/puppet/pops/loader/null_loader.rb

@@ -0,0 +1,60 @@
+# The null loader is empty and delegates everything to its parent if it has one.
+#
+class Puppet::Pops::Loader::NullLoader < Puppet::Pops::Loader::Loader
+  attr_reader :loader_name
+
+  # Construct a NullLoader, optionally with a parent loader
+  #
+  def initialize(parent_loader=nil, loader_name = "null-loader")
+    super(loader_name)
+    @parent = parent_loader
+  end
+
+  # Has parent if one was set when constructed
+  def parent
+    @parent
+  end
+
+  def find(typed_name)
+    if @parent.nil?
+      nil
+    else
+      @parent.find(typed_name)
+    end
+  end
+
+  def load_typed(typed_name)
+    if @parent.nil?
+      nil
+    else
+      @parent.load_typed(typed_name)
+    end
+  end
+
+  def loaded_entry(typed_name, check_dependencies = false)
+    if @parent.nil?
+      nil
+    else
+      @parent.loaded_entry(typed_name, check_dependencies)
+    end
+  end
+
+  # Has no entries on its own - always nil
+  def get_entry(typed_name)
+    nil
+  end
+
+  # Finds nothing, there are no entries
+  def find(name)
+    nil
+  end
+
+  # Cannot store anything
+  def set_entry(typed_name, value, origin = nil)
+    nil
+  end
+
+  def to_s()
+    "(NullLoader '#{loader_name}')"
+  end
+end