You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: symbol_conversion.rb
    path of file: ./repos/rubocop/lib/rubocop/cop/lint
    
    the code of the file until where you have to start completion: # frozen_string_literal: true

module RuboCop
  module Cop
    module Lint
      # Checks for uses of literal strings converted to
      # a symbol where a literal symbol could be used instead.
      #
      # There are two possible styles for this cop.
      # `strict` (default) will register an offense for any incorrect usage.
      # `consistent` additionally requires hashes to use the same style for
      # every symbol key (ie. if any symbol key needs to be quoted it requires
      # all keys to be quoted).
      #
      # @example
      #   # bad
      #   'string'.to_sym
      #   :symbol.to_sym
      #   'underscored_string'.to_sym
      #   :'underscored_symbol'
      #   'hyphenated-string'.to_sym
      #   "string_#{interpolation}".to_sym
      #
      #   # good
      #   :string
      #   :symbol
      #   :underscored_string
      #   :underscored_symbol
      #   :'hyphenated-string'
      #   :"string_#{interpolation}"
      #
      # @example EnforcedStyle: strict (default)
      #
      #   # bad
      #   {
      #     'a': 1,
      #     "b": 2,
      #     'c-d': 3
      #   }
      #
      #   # good (don't quote keys that don't require quoting)
      #   {
      #     a: 1,
      #     b: 2,
      #     'c-d': 3
      #   }
      #
      # 
    
        def properly_quoted?(source, value)
          return true if style == :strict && (!source.match?(/['"]/) || value.end_with?('='))

          source == value ||
            # `Symbol#inspect` uses double quotes, but allow single-quoted
            # symbols to work as well.
            source.gsub('"', '\"').tr("'", '"') == value
        end

        def requires_quotes?(sym_node)
          sym_node.value.inspect.match?(/^:".*?"|=$/)
        end

        def in_alias?(node)
          node.parent&.alias_type?
        end

        def in_percent_literal_array?(node)
          node.parent&.array_type? && node.parent&.percent_literal?
        end

        def correct_hash_key(node)
          # Although some operators can be converted to symbols normally
          # (ie. `:==`), these are not accepted as hash keys and will
          # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
          # symbol does not start with an alphanumeric or underscore, it
          # will be ignored.
          return unless node.value.to_s.match?(/\A[a-z0-9_]/i)

          correction = node.value.inspect
          correction = correction.delete_prefix(':') if node.parent.colon?
          return if properly_quoted?(node.source, correction)

          register_offense(
            node,
            correction: correction,
            message: format(MSG, correction: node.parent.colon? ? "#{correction}:" : correction)
          )
        end

        def correct_inconsistent_hash_keys(keys)
          keys.each do |key|
            ignore_node(key)

            next if requires_quotes?(key)
            next if properly_quoted?(key.source, %("#{key.value}"))

            correction = %("#{key.value}")
            register_offense(
              key,
              correction: correction,
              message: format(MSG_CONSISTENCY, correction: "#{correction}:")
            )
          end
        end
      end
    end