objc2swift_assistant 0.3.0

data/lib/objc2swift_assistant/logging.rb

@@ -0,0 +1,19 @@
+require_relative "version"
+
+module Objc2swiftAssistantLogging
+
+  LOG_LEVEL_ERRORS      = 4
+  LOG_LEVEL_WARNINGS    = 3
+  LOG_LEVEL_VERBOSE     = 2
+  LOG_LEVEL_DEBUG       = 1
+  LOG_LEVEL_NONE        = 0
+
+  LOG_LEVELS_BY_NAME = [
+      "error" => LOG_LEVEL_ERRORS,
+      "warning" => LOG_LEVEL_WARNINGS ,
+      "verbose" => LOG_LEVEL_VERBOSE ,
+      "debug" => LOG_LEVEL_DEBUG,
+      "none" => LOG_LEVEL_NONE
+  ]
+
+end

data/lib/objc2swift_assistant/objc_2_swift.rb

@@ -0,0 +1,734 @@
+require_relative 'version'
+
+require_relative 'file_sets'
+require_relative 'recognizers/recognizer_keys'
+require_relative 'objc_2_swift_type_mapping'
+require_relative 'objc_2_swift_block_conversion'
+require_relative 'processing_element'
+
+module Objc2swiftAssistant
+
+  def cleanup_method_body_lines( file_lines )
+    cleaned_up = []
+    file_lines.each do |line|
+      no_trailing = line.rstrip
+      next if no_trailing.strip == '@end'
+      cleaned_up << no_trailing if no_trailing.length > 0
+    end
+
+    cleaned_up
+  end
+  module_function :cleanup_method_body_lines
+
+  def prepare_class_header_lines( file_lines )
+    cleaned_up = []
+    file_lines.each do |line|
+      no_trailing = line.rstrip
+      cleaned_up << '// ' + no_trailing if no_trailing.length > 0
+    end
+
+    cleaned_up
+  end
+  module_function :prepare_class_header_lines
+
+  def prepare_method_body_lines( lines )
+    raw_body_lines = cleanup_method_body_lines( lines )
+    body_lines = raw_body_lines.map do |line|
+      '// ' + line
+    end
+
+    body_lines
+  end
+  module_function :prepare_method_body_lines
+
+
+  class ObjC2SwiftFileConverter < FailableProcessingElement
+    attr_accessor :objc_file_node
+    attr_accessor :enums
+    attr_accessor :classes_by_name
+    attr_accessor :categories_by_class_and_name
+    attr_accessor :protocols
+    attr_accessor :swift_file_node
+    attr_accessor :configuration
+
+    attr_accessor :access_control_state
+    attr_accessor :protocol_optional_state
+
+    def initialize( objc_file_node, configuration )
+      @objc_file_node = objc_file_node
+      @configuration = configuration
+      @enums = {}
+      @classes_by_name = {}
+      @categories_by_class_and_name = {}
+      @protocols = []
+
+      @access_control_state = nil
+      @protocol_optional_state = false
+    end
+
+    def prepare( )
+      @objc_file_node.root_matches.each do |region|
+
+        if region.region_type == CLASS_INTERFACE_KEY
+          class_converter = class_for_name( region.class_name )
+          class_converter.interface_region = region
+          process_interface_sub_regions( region, class_converter )
+        elsif region.region_type == CLASS_IMPLEMENTATION_KEY
+          class_converter = class_for_name( region.class_name )
+          class_converter.implementation_region = region
+          process_impl_sub_regions( region, class_converter )
+        elsif region.region_type == EXTENSION_DECLARARATION_KEY
+          class_converter = class_for_name( region.class_name )
+          extension_converter = ObjC2SwiftCategoryConverter.new( self, region.class_name, nil, @configuration   )
+          extension_converter.interface_region = region
+          class_converter.extension_converter = extension_converter
+        elsif region.region_type == CATEGORY_DECLARARATION_KEY
+          category_converter = category_for_class_and_name( region.class_name, region.category_name  )
+          category_converter.interface_region = region
+          process_interface_sub_regions( region, category_converter )
+        elsif region.region_type == CATEGORY_IMPLEMENTATION_KEY
+          category_converter = category_for_class_and_name( region.class_name, region.category_name  )
+          category_converter.implementation_region = region
+          process_impl_sub_regions( region, category_converter )
+        elsif region.region_type == PROTOCOL_DECLARATION_KEY
+          protocol_converter = ObjC2SwiftProtocolConverter.new( self, region.protocol_name, @configuration )
+          protocol_converter.interface_region = region
+          @protocols << protocol_converter
+          process_interface_sub_regions( region, protocol_converter )
+
+          # category_converter.implementation_region = region
+          # process_impl_sub_regions( region, category_converter )
+          @configuration.log_warning( "protocols NYI")
+        elsif region.region_type == ENUM_DECLARATION_KEY
+          @configuration.log_warning( "Not Yet Implemented Region Type: #{region.region_type.to_s}")
+        elsif region.region_type == PRAGMA_MARK_KEY
+          @configuration.log_warning( "Not Yet Implemented Region Type: #{region.region_type.to_s}")
+        else
+          @configuration.log_warning( "Unexpected Root Region Type: #{region.region_type.to_s}")
+        end
+      end # Iterating over root matches
+
+      @classes_by_name.each_value do |class_converter|
+        class_converter.prepare
+      end
+
+      @categories_by_class_and_name.each do |_, category_converter|
+        category_converter.prepare
+      end
+
+      @protocols.each do | protcol_converter|
+        protcol_converter.prepare
+      end
+    end
+
+    # common logic for class-like entities (classes, categories, extensions)
+    def process_interface_sub_regions( interface_region, class_converter )
+
+      @configuration.log_verbose( "\nprocess_interface_sub_regions") unless interface_region.sub_regions.length == 0
+
+      interface_region.sub_regions.each do |sub_region|
+        @configuration.log_verbose( "#{sub_region.region_type} #{sub_region.starting_line_number} #{sub_region.detection_line}" )
+
+        if sub_region.region_type == PROPERTY_DECLARATION_KEY
+          property = class_converter.property_for_name( sub_region.name )
+          property.declaration_region = sub_region
+          property.access_control_state = @access_control_state
+          property.protocol_optional_state = @protocol_optional_state
+        elsif sub_region.region_type == METHOD_DECLARATION_KEY
+          method = class_converter.method_for_signature( sub_region.objc_signature )
+          method.declaration_region = sub_region
+          method.access_control_state = @access_control_state
+          method.protocol_optional_state = @protocol_optional_state
+        elsif sub_region.region_type == AT_DIRECTIVE_KEY
+          process_at_directive_region( sub_region )
+        else
+          unexpected_sub_region( sub_region, interface_region )
+        end
+      end
+    end
+
+    # common logic for class-like entities (classes, categories)
+    def process_impl_sub_regions( impl_region, class_converter )
+      impl_region.sub_regions.each do |sub_region|
+        if sub_region.region_type == METHOD_IMPLEMENTATION_KEY
+          method = class_converter.method_for_signature( sub_region.objc_signature )
+          method.implementation_region = sub_region
+        else
+          unexpected_sub_region( sub_region, impl_region )
+        end
+      end
+    end
+
+    def process_at_directive_region( region )
+      directive = region.directive_symbol
+
+      if( directive == :required )
+        @protocol_optional_state = directive
+      elsif ( directive == :optional )
+        @protocol_optional_state = directive
+      elsif ( [:public, :private, :protected].include? directive )
+        @access_control_state = directive
+      else
+        add_error( "unknown '@' directive: #{directive}")
+      end
+    end
+
+    def generate( generator_defs, configuration, dry_run )
+      @configuration.log_verbose( "Generating #{@swift_file_node.relative_path} at #{@swift_file_node.full_path}" )
+
+      @enums.each do |enum_converter|
+
+      end
+
+      @classes_by_name.each do |key, class_converter|
+        class_converter.generate( generator_defs, @swift_file_node.relative_path, configuration, dry_run )
+      end
+
+      @categories_by_class_and_name.each do |_, category_converter|
+        category_converter.generate( generator_defs, @swift_file_node.relative_path, configuration, dry_run )
+      end
+
+      @protocols.each do | protcol_converter|
+        protcol_converter.generate( generator_defs, @swift_file_node.relative_path, configuration, dry_run )
+      end
+    end
+
+    # Utility
+
+    def class_for_name( class_name )
+      class_converter = @classes_by_name[ class_name ]
+      if class_converter.nil?
+        class_converter = ObjC2SwiftClassConverter.new( self, class_name, @configuration )
+        @classes_by_name[ class_name ] = class_converter
+      end
+
+      class_converter
+    end
+
+    def category_for_class_and_name( class_name, category_name )
+      the_key = [class_name, category_name]
+      category_converter = @categories_by_class_and_name[ the_key ]
+      if category_converter.nil?
+        category_converter = ObjC2SwiftCategoryConverter.new( self, class_name, category_name, @configuration )
+        @categories_by_class_and_name[ [class_name, category_name] ] = category_converter
+      end
+
+      category_converter
+    end
+
+    def unexpected_sub_region( sub_region, region )
+      @configuration.log_warning( "Unexpected Sub Region Type: #{sub_region.region_type.to_s} of #{region.region_type.to_s}")
+    end
+
+    def cannonical_source_file_path
+      objc_file_node.cannonical_source_file_path
+    end
+
+    def dump( indent, tab, errors_only )
+        puts( "#{indent}Generating Swift file #{@swift_file_node.relative_path} at #{@swift_file_node.full_path}" )
+
+        #objc_file_node
+        #enums
+        puts( "\n#{indent}Generated Classes:" ) unless @classes_by_name.length == 0
+        @classes_by_name.each do  | _, class_converter |
+          puts( "#{indent+tab}#{class_converter.class_name}" )
+        end
+
+        puts( "\n#{indent}Generated Categories:" ) unless @categories_by_class_and_name.length == 0
+        @categories_by_class_and_name.each do | _, category_converter |
+          category_str = category_converter.category_name.nil? ? "" : " /*#{category_converter.category_name}*/"
+          puts( "#{indent+tab}#{category_converter.class_name}#{category_str}" )
+        end
+
+        puts( "\n#{indent}Generated Prototcols:" ) unless @protocols.length == 0
+        @protocols.each do  | protocol |
+          puts( "#{indent+tab}#{protocol.class_name}" )
+        end
+
+      #protocols
+        #configuration
+    end
+
+  end
+
+
+  class ObjC2SwiftCodeConverter < FailableProcessingElement
+    attr_accessor :file_converter
+    attr_accessor :marks
+    attr_accessor :configuration
+
+    def initialize( file_converter, configuration )
+      super()
+      @file_converter = file_converter
+      @configuration = configuration
+      @marks = []
+    end
+
+    def add_mark_region( mark_region )
+      @marks << mark_region
+    end
+    # Utility
+
+    def cannonical_source_file_path
+      file_converter.cannonical_source_file_path
+    end
+
+    def configuration
+      @file_converter.configuration
+    end
+
+    # Configuration
+    def omit_file()
+      configuration.omit_file( cannonical_source_file_path )
+    end
+
+    def company_name()
+      configuration.company_name( cannonical_source_file_path )
+    end
+
+    def emit_original_signatures()
+      configuration.emit_original_signatures( cannonical_source_file_path )
+    end
+
+    def emit_original_bodies()
+      configuration.emit_original_bodies( cannonical_source_file_path )
+    end
+
+    def emit_unconverted_content()
+      configuration.emit_unconverted_content( cannonical_source_file_path )
+    end
+  end
+
+  class ObjC2SwiftClassLikeConverter < ObjC2SwiftCodeConverter
+    attr_accessor :methods_by_signature
+    attr_accessor :properties_by_name
+    attr_accessor :interface_region
+    attr_accessor :implementation_region
+
+    def initialize( file_converter, class_name, configuration )
+      super( file_converter, configuration )
+      @class_name = class_name
+      @methods_by_signature = {}
+      @properties_by_name = {}
+    end
+
+    def method_for_signature( method_signature )
+      method_converter = @methods_by_signature[ method_signature]
+      if method_converter.nil?
+        method_converter = ObjC2SwiftMethodConverter.new( self, method_signature, @configuration )
+        @methods_by_signature[ method_signature ] = method_converter
+      end
+      method_converter
+    end
+
+    def property_for_name( property_name )
+      property_converter = @properties_by_name[ property_name]
+      if property_converter.nil?
+        property_converter = ObjC2SwiftPropertyConverter.new( self, property_name, @configuration )
+        @properties_by_name[ property_name ] = property_converter
+      end
+      property_converter
+    end
+
+    ## Hook for subclasses
+    def process_new_property_converter( property_converter )
+    end
+
+    # Error Handling
+
+    def has_errors( or_warnings )
+      has_em = super.has_errors( or_warnings )
+
+      has_em |= @interface_region.has_errors( or_warnings ) unless @interface_region.nil?
+      has_em |= @implementation_region.has_errors( or_warnings ) unless @implementation_region.nil?
+
+      has_em |= dictionary_has_errors( @methods_by_signature, or_warnings  )
+      has_em |= dictionary_has_errors( @properties_by_name, or_warnings )
+
+      has_em
+    end
+
+  end
+
+
+  class ObjC2SwiftClassConverter < ObjC2SwiftClassLikeConverter
+    attr_accessor :class_name
+    attr_accessor :super_class
+    attr_accessor :extension_converter
+
+    def initialize( file_converter, class_name, configuration )
+      super( file_converter, class_name, configuration )
+      @extension_region = nil
+    end
+
+    def prepare
+      methods = all_methods
+      properties = all_properties
+
+      methods.each do |method_converter|
+        method_converter.compute_swift_name
+      end
+
+      properties.each do |property_converter|
+        methods.each do |method_converter|
+          property_converter.check_method_for_association(method_converter)
+        end
+        property_converter.prepare
+      end
+
+      methods.each do |method_converter|
+        method_converter.prepare
+      end
+    end
+
+    def all_methods
+      methods = @methods_by_signature.values.clone
+      methods << @extension_region.methods_by_signature.all_values unless @extension_region.nil?
+      # Categories are handled as seperate entities
+      # @category_regions_by_name.inject( methods ) { |m, (k, v)| m << v.methods_by_signature; m }
+      methods
+    end
+
+    def all_properties
+      properties = @properties_by_name.values.clone
+      properties << @extension_region.properties_by_name.all_values unless @extension_region.nil?
+      # Categories are handled as seperate entities
+      # @category_regions_by_name.inject( properties ) { |p, (k, v)| p << v.properties_by_name; p }
+      properties
+    end
+
+    def generate( generator_defs, file_name, configuration, dry_run )
+      generated_class = make_generator_class_object( generator_defs, file_name )
+      generated_class.source_file.company_name = configuration.company_name( cannonical_source_file_path.to_s ) unless cannonical_source_file_path.nil?
+
+      if ! @interface_region.nil? && emit_unconverted_content()
+        generated_class.top_inner_comment_block = Objc2swiftAssistant::prepare_class_header_lines( @interface_region.root_header )
+      end
+
+      properties_by_name.each do | _, property |
+        property.generate( generated_class, configuration, dry_run )
+      end
+
+      methods_by_signature.each do | _, method |
+        method.generate( generated_class, configuration, dry_run )
+      end
+    end
+
+    def make_generator_class_object( generator_defs, file_name )
+      @configuration.log_verbose( "------- #{@interface_region.implements}" ) unless @interface_region.nil?
+      if @interface_region.nil?
+        implements_list =[]
+      else
+        implements_list = @interface_region.super_class.nil? ? [] : [@interface_region.super_class]
+        implements_list << @interface_region.implements unless @interface_region.implements.nil? || @interface_region.implements.length == 0
+      end
+
+      SwiftGenerator::SwiftClass.new( generator_defs, class_name, implements_list, file_name:file_name.to_s, characteristics:[] )
+    end
+
+    def make_modifiers( access_control:nil, optional:nil )
+      return [] if access_control.nil?
+
+      return [access_control.to_s]
+    end
+
+  end
+
+
+  class ObjC2SwiftCategoryConverter < ObjC2SwiftClassConverter
+    attr_accessor :category_name
+
+    def initialize( file_converter, class_name, category_name, configuration )
+      super( file_converter, class_name, configuration )
+      @category_name = category_name
+    end
+
+    def make_generator_class_object( generator_defs, file_name )
+      SwiftGenerator::SwiftCategory.new( generator_defs, category_name, class_name, file_name:file_name.to_s, characteristics:[] )
+    end
+
+  end
+
+  class ObjC2SwiftProtocolConverter < ObjC2SwiftClassConverter
+
+    def initialize( file_converter, protocol_name, configuration )
+      super( file_converter, protocol_name, configuration )
+      # super( file_converter, class_name )
+      # @extension_region = nil
+    end
+
+    def make_generator_class_object( generator_defs, file_name )
+      extends_list = @interface_region.extends || []
+      SwiftGenerator::SwiftProtocol.new( generator_defs, class_name, extends_list, file_name:file_name.to_s, characteristics:[] )
+    end
+
+    def prepare( )
+      super( )
+      all_properties.each do |property_converter|
+
+        if property_converter.declaration_region.modifiers.include?( 'readonly' )   #declaration_region must exist
+          property_converter.protocol_get_set_spec = "{ get }"
+        else
+          property_converter.protocol_get_set_spec = "{ get set }"
+        end
+      end
+    end
+
+    def make_modifiers( access_control:nil, optional:nil )
+      access_qualifiers = super( access_control:access_control, optional:optional )
+
+      return access_qualifiers if optional.nil?
+
+      if optional == :optional
+        access_qualifiers << 'optional'
+      end
+
+      access_qualifiers
+    end
+  end
+
+  class ObjC2SwiftMethodConverter < ObjC2SwiftCodeConverter
+    attr_accessor :class_converter
+    attr_accessor :objc_signature
+    attr_accessor :swift_name
+    attr_accessor :declaration_region
+    attr_accessor :implementation_region
+    attr_accessor :owning_property
+    attr_accessor :parameters
+    attr_accessor :is_initializer
+
+    attr_accessor :access_control_state
+    attr_accessor :protocol_optional_state
+
+
+    def initialize( class_converter, objc_signature, configuration )
+      super( class_converter.file_converter, configuration )
+
+      @class_converter = class_converter
+      @objc_signature = objc_signature
+      @is_initializer = false
+      @parameters = nil
+      @access_control_state = nil
+      @protocol_optional_state = nil
+    end
+
+    def compute_swift_name
+      #Copy the parameters from the method region
+      @parameters = Marshal.load(Marshal.dump(@declaration_region.parameters)) unless @declaration_region.nil?
+      @parameters= Marshal.load(Marshal.dump(@implementation_region.parameters)) if @parameters.nil? unless @implementation_region.nil?
+      split_first_param_name
+    end
+
+    def prepare
+    end
+
+    def split_first_param_name()
+      # Note parameters are instances of MethodParameter
+      # return if @parameters.length == 0
+
+      p1 = @parameters[ 0 ]
+
+      m = p1.param_label.match( /(initWith|init)(?<arg_name>\w*)/ )
+      unless m.nil?
+        arg_name = m[ 'arg_name' ]
+        if arg_name.nil?
+          p1.param_label = nil
+        elsif arg_name.length < 3
+          p1.param_label = arg_name.downcase
+        else
+          p1.param_label = arg_name[0, 1].downcase + arg_name[1..-1]
+        end
+
+        @swift_name = 'init'
+        @is_initializer = true
+      else
+        @swift_name = @parameters[ 0 ].param_label
+        # p1.param_label = nil
+      end
+
+      if @parameters.length == 1 && (p1.param_type.nil? || p1.param_type.length == 0)
+        @parameters = []
+      end
+    end
+
+    def generate( generated_class, configuration, dry_run )
+      return unless @owning_property.nil?
+
+      # type_symbol = @declaration_region.type_name.to_sym
+      # mutability = @declaration_region.is_pointer ? :var : :let
+
+      method_region = @declaration_region || @implementation_region
+
+      if @is_initializer
+        generated_method = SwiftGenerator::SwiftInitializer.new( generated_class, @swift_name, arg_list( configuration ), override: false, comment: nil )
+      else
+        returns_str = swift_type_string( configuration, method_region.return_type, method_region.return_pointer_level, method_region.return_nillable_qualifier )
+        # returns = configuration.type_mapper.swift_type_for_objc_type( returns_str )
+        # TODO: handle block returns
+        returns = nil if returns == 'void'
+        generated_method = SwiftGenerator::SwiftMethod.new( generated_class, @swift_name, arg_list( configuration ), @is_initializer ? nil : returns, override: false, comment: nil )
+      end
+
+      generated_method.access_control_modifiers = class_converter.make_modifiers( access_control:@access_control_state,
+                                                                                 optional:@protocol_optional_state )
+      generated_method << body_lines_to_emit
+
+      unless method_region.return_type.nil?
+
+        # TODO: Dummy Return Statements
+        # @return_nillable_qualifier = ''    # Not yet implemented
+        # @return_type = m[ 'return_type' ]
+        # @return_pointer_level = m[ 'return_pointer' ].nil? ? 0 : m[ 'return_pointer' ].length
+
+      end
+    end
+
+    def arg_list( configuration )
+      param_strings = @parameters.map do |parameter|
+        arg_string( parameter, configuration )
+      end
+
+      param_strings.join( ", " )
+    end
+
+    def arg_string( param, configuration )
+      if param.is_block_type
+        block_signature = configuration.block_converter.block_sig_for_method_arg( param.param_type )
+        type_string = block_signature.swift_declaration
+      else
+        type_string = swift_type_string( configuration, param.param_type, param.pointer_level, param.null_qualifier, param.is_weak )
+      end
+
+      if param.param_name.nil? || param.param_name == param.param_label
+        sig = param.param_label
+      else
+        sig = "#{param.param_label} #{param.param_name}"
+      end
+
+      sig ||= '/* Unknown */'
+      sig += ": #{type_string}"
+      sig
+    end
+
+
+    def swift_type_string( configuration, param_type, pointer_level, null_qualifier, is_weak=false  )
+      mapped_param_type = configuration.type_mapper.swift_type_for_objc_type( param_type )
+
+      mapped_param_type = "/*__weak*/ #{mapped_param_type}" if is_weak
+
+      if( pointer_level == 2 )
+        if mapped_param_type == "NSError"
+            return 'NSErrorPointer'
+        else
+          return "AutoreleasingUnsafeMutablePointer<#{mapped_param_type}?>"
+        end
+      else
+        return "#{mapped_param_type}#{nullable_qualifier(null_qualifier, pointer_level)}" unless mapped_param_type.nil?
+      end
+    end
+
+    def nullable_qualifier( null_qualifier, pointer_level )
+      pointer_chars = ''
+      if( pointer_level > 1)
+        pointer_chars = '**********'[0..pointer_level]    # Almost sure to be incorrect, but reflects original code
+      end
+
+      if null_qualifier == '__nonnull' && pointer_level > 0
+        return pointer_chars + '!'
+      elsif null_qualifier ==  '__nullable'
+        return pointer_chars + '?'
+      elsif null_qualifier ==  '__null_unspecified'
+        return pointer_chars + '!'
+      elsif pointer_level > 0
+        return pointer_chars + '!'
+      else
+        return pointer_chars
+      end
+    end
+
+    def body_lines_to_emit()
+      if @implementation_region.nil?
+        return []
+      end
+
+      lines = []
+      if emit_original_bodies
+        if emit_original_signatures
+          lines = implementation_region.all_lines
+        else
+          lines = implementation_region.unmatched_lines
+        end
+      end
+
+      return  Objc2swiftAssistant::prepare_method_body_lines( lines )
+    end
+
+  end
+
+  class ObjC2SwiftPropertyConverter < ObjC2SwiftCodeConverter
+    attr_accessor :class_converter
+    attr_accessor :property_name
+    attr_accessor :declaration_region
+    attr_accessor :getter_method_converter
+    attr_accessor :setter_method_converter
+    attr_accessor :protocol_get_set_spec # Must be set if part of a protocol definition
+
+    attr_accessor :access_control_state
+    attr_accessor :protocol_optional_state
+
+    def initialize( class_converter, property_name, configuration )
+      super( class_converter.file_converter, configuration )
+      @class_converter = class_converter
+      @property_name = property_name
+      @protocol_get_set_spec = nil
+
+      @access_control_state = nil
+      @protocol_optional_state = nil
+    end
+
+    def prepare
+    end
+
+    def check_method_for_association( method_converter )
+      if Objc2swiftAssistant::is_getter_method_name( property_name, method_converter.swift_name )
+        @getter_method_converter = method_converter
+        method_converter.owning_property = self
+      elsif Objc2swiftAssistant::is_setter_method_name( property_name, method_converter.swift_name )
+        @setter_method_converter = method_converter
+        method_converter.owning_property = self
+      end
+    end
+
+    def generate( generated_class, configuration, dry_run )
+      if @declaration_region.is_block_property
+        block_signature = configuration.block_converter.block_sig_for_components( @declaration_region.block_return_type,  @declaration_region.block_args )
+        declaration_string = block_signature.swift_declaration( true )
+        generated = SwiftGenerator::SwiftBlockProperty.new( generated_class, @property_name, declaration_string, :optional )
+      else
+        type_symbol = configuration.type_mapper.swift_type_for_objc_type( @declaration_region.type_name ).to_sym
+        mutability = @declaration_region.is_pointer ? :var : :let
+        # puts( "NYI: mutability" )
+        generated = SwiftGenerator::SwiftProperty.new( generated_class, @property_name, type_symbol, :optional )
+      end
+
+      generated.protocol_get_set_spec = @protocol_get_set_spec unless @protocol_get_set_spec.nil?     # Used in protocol declarations
+
+      unless @getter_method_converter.nil?
+        generated.getter_body = Objc2swiftAssistant::prepare_method_body_lines( @getter_method_converter.implementation_region.unmatched_lines || [] )
+      end
+
+      unless @setter_method_converter.nil?
+        generated.setter_body = Objc2swiftAssistant::prepare_method_body_lines( @setter_method_converter.implementation_region.unmatched_lines || [] )
+      end
+
+      generated.access_control_modifiers = class_converter.make_modifiers( access_control:@access_control_state,
+                                                                                 optional:@protocol_optional_state )
+    end
+
+  end
+
+  class ObjC2SwiftEnumConverter
+
+  end
+
+end