tapioca 0.6.1 → 0.7.0

data/lib/tapioca/helpers/shims_helper.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module ShimsHelper
+    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Thor::Shell }
+
+    sig { params(index: RBI::Index, kind: String, dir: String).void }
+    def index_rbis(index, kind, dir)
+      return unless Dir.exist?(dir) && !Dir.empty?(dir)
+
+      say("Loading #{kind} RBIs from #{dir}... ")
+      files = Dir.glob("#{dir}/**/*.rbi").sort
+
+      trees = files.map do |file|
+        RBI::Parser.parse_file(file)
+      rescue RBI::ParseError => e
+        say_error("\nWarning: #{e} (#{e.location})", :yellow)
+      end.compact
+
+      index.visit_all(trees)
+      say(" Done", :green)
+    end
+
+    sig { params(index: RBI::Index, shim_rbi_dir: String).returns(T::Hash[String, T::Array[RBI::Node]]) }
+    def duplicated_nodes_from_index(index, shim_rbi_dir)
+      duplicates = {}
+      say("Looking for duplicates... ")
+      index.keys.each do |key|
+        nodes = index[key]
+        next unless shims_have_duplicates?(nodes, shim_rbi_dir)
+        duplicates[key] = nodes
+      end
+      say(" Done", :green)
+      duplicates
+    end
+
+    private
+
+    sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String).returns(T::Boolean) }
+    def shims_have_duplicates?(nodes, shim_rbi_dir)
+      return false if nodes.size == 1
+
+      shims = extract_shims(nodes, shim_rbi_dir)
+      return false if shims.empty?
+
+      props = extract_methods_and_attrs(shims)
+      return false if props.empty?
+
+      shims_with_sigs = extract_nodes_with_sigs(props)
+      shims_with_sigs.each do |shim|
+        shim_sigs = shim.sigs
+
+        extract_methods_and_attrs(nodes).each do |node|
+          next if node == shim
+          return true if shim_sigs.all? { |sig| node.sigs.include?(sig) }
+        end
+
+        return false
+      end
+
+      true
+    end
+
+    sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String).returns(T::Array[RBI::Node]) }
+    def extract_shims(nodes, shim_rbi_dir)
+      nodes.select do |node|
+        node.loc&.file&.start_with?(shim_rbi_dir)
+      end
+    end
+
+    sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
+    def extract_methods_and_attrs(nodes)
+      T.cast(nodes.select do |node|
+        node.is_a?(RBI::Method) || node.is_a?(RBI::Attr)
+      end, T::Array[T.any(RBI::Method, RBI::Attr)])
+    end
+
+    sig { params(nodes: T::Array[T.any(RBI::Method, RBI::Attr)]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
+    def extract_nodes_with_sigs(nodes)
+      nodes.reject { |node| node.sigs.empty? }
+    end
+  end
+end

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "pathname"
+require "shellwords"
+
+module Tapioca
+  module SorbetHelper
+    extend T::Sig
+
+    SORBET_GEM_SPEC = T.let(
+      ::Gem::Specification.find_by_name("sorbet-static"),
+      ::Gem::Specification
+    )
+
+    SORBET_BIN = T.let(
+      Pathname.new(SORBET_GEM_SPEC.full_gem_path) / "libexec" / "sorbet",
+      Pathname
+    )
+
+    SORBET_EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
+
+    FEATURE_REQUIREMENTS = T.let({
+      # First tag that includes https://github.com/sorbet/sorbet/pull/4706
+      to_ary_nil_support: ::Gem::Requirement.new(">= 0.5.9220"),
+    }.freeze, T::Hash[Symbol, ::Gem::Requirement])
+
+    class CmdResult < T::Struct
+      const :out, String
+      const :err, String
+      const :status, T::Boolean
+    end
+
+    sig { params(sorbet_args: String).returns(CmdResult) }
+    def sorbet(*sorbet_args)
+      out, err, status = Open3.capture3([sorbet_path, *sorbet_args].join(" "))
+      CmdResult.new(out: out, err: err, status: status.success? || false)
+    end
+
+    sig { returns(String) }
+    def sorbet_path
+      sorbet_path = ENV.fetch(SORBET_EXE_PATH_ENV_VAR, SORBET_BIN)
+      sorbet_path = SORBET_BIN if sorbet_path.empty?
+      sorbet_path.to_s.shellescape
+    end
+
+    sig { params(feature: Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
+    def sorbet_supports?(feature, version: nil)
+      version = SORBET_GEM_SPEC.version unless version
+      requirement = FEATURE_REQUIREMENTS[feature]
+
+      Kernel.raise "Invalid Sorbet feature #{feature}" unless requirement
+
+      requirement.satisfied_by?(version)
+    end
+  end
+end

data/lib/tapioca/helpers/test/dsl_compiler.rb

@@ -0,0 +1,118 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca/helpers/test/content"
+require "tapioca/helpers/test/isolation"
+require "tapioca/helpers/test/template"
+
+module Tapioca
+  module Helpers
+    module Test
+      module DslCompiler
+        extend T::Sig
+        extend T::Helpers
+
+        include Isolation
+        include Content
+        include Template
+
+        requires_ancestor { Kernel }
+
+        sig { params(compiler_class: T.class_of(Tapioca::Dsl::Compiler)).void }
+        def use_dsl_compiler(compiler_class)
+          @context = T.let(CompilerContext.new(compiler_class), T.nilable(CompilerContext))
+        end
+
+        sig { params(compiler_classes: T.class_of(Tapioca::Dsl::Compiler)).void }
+        def activate_other_dsl_compilers(*compiler_classes)
+          context.activate_other_dsl_compilers(compiler_classes)
+        end
+
+        sig { params(constant_name: T.any(Symbol, String)).returns(String) }
+        def rbi_for(constant_name)
+          context.rbi_for(constant_name)
+        end
+
+        sig { returns(T::Array[String]) }
+        def gathered_constants
+          context.gathered_constants
+        end
+
+        sig { returns(T::Array[String]) }
+        def generated_errors
+          context.errors
+        end
+
+        sig { returns(CompilerContext) }
+        def context
+          raise "Please call `use_dsl_compiler` before" unless @context
+          @context
+        end
+
+        class CompilerContext
+          extend T::Sig
+
+          sig { returns(T.class_of(Tapioca::Dsl::Compiler)) }
+          attr_reader :compiler_class
+
+          sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+          attr_reader :other_compiler_classes
+
+          sig { params(compiler_class: T.class_of(Tapioca::Dsl::Compiler)).void }
+          def initialize(compiler_class)
+            @compiler_class = compiler_class
+            @other_compiler_classes = T.let([], T::Array[T.class_of(Tapioca::Dsl::Compiler)])
+            @pipeline = T.let(nil, T.nilable(Tapioca::Dsl::Pipeline))
+            @errors = T.let([], T::Array[String])
+          end
+
+          sig { params(compiler_classes: T::Array[T.class_of(Tapioca::Dsl::Compiler)]).void }
+          def activate_other_dsl_compilers(compiler_classes)
+            @other_compiler_classes = compiler_classes
+          end
+
+          sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+          def activated_compiler_classes
+            [compiler_class, *other_compiler_classes]
+          end
+
+          sig { returns(T::Array[String]) }
+          def gathered_constants
+            compiler_class.processable_constants.map(&:name).compact.sort
+          end
+
+          sig { params(constant_name: T.any(Symbol, String)).returns(String) }
+          def rbi_for(constant_name)
+            # Make sure this is a constant that we can handle.
+            unless gathered_constants.include?(constant_name.to_s)
+              raise "`#{constant_name}` is not processable by the `#{compiler_class}` compiler."
+            end
+
+            file = RBI::File.new(strictness: "strong")
+            constant = Object.const_get(constant_name)
+
+            compiler = compiler_class.new(pipeline, file.root, constant)
+            compiler.decorate
+
+            Tapioca::DEFAULT_RBI_FORMATTER.print_file(file)
+          end
+
+          sig { returns(T::Array[String]) }
+          def errors
+            pipeline.errors
+          end
+
+          private
+
+          sig { returns(Tapioca::Dsl::Pipeline) }
+          def pipeline
+            @pipeline ||= Tapioca::Dsl::Pipeline.new(
+              requested_constants: [],
+              requested_compilers: activated_compiler_classes
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/helpers/test/isolation.rb

@@ -100,7 +100,7 @@ module Tapioca
                   load_path_args << File.expand_path(p)
                 end
 
-                child = IO.popen([env, Gem.ruby, *load_path_args, $PROGRAM_NAME, *ORIG_ARGV, test_opts])
+                child = IO.popen([env, ::Gem.ruby, *load_path_args, $PROGRAM_NAME, *ORIG_ARGV, test_opts])
 
                 begin
                   Process.wait(child.pid)

data/lib/tapioca/helpers/test/template.rb

@@ -7,15 +7,18 @@ module Tapioca
   module Helpers
     module Test
       module Template
-        include Kernel
         extend T::Sig
+        extend T::Helpers
+
+        requires_ancestor { Kernel }
+
         ERB_SUPPORTS_KVARGS = T.let(
           ::ERB.instance_method(:initialize).parameters.assoc(:key), T.nilable([Symbol, Symbol])
         )
 
         sig { params(selector: String).returns(T::Boolean) }
         def ruby_version(selector)
-          Gem::Requirement.new(selector).satisfied_by?(Gem::Version.new(RUBY_VERSION))
+          ::Gem::Requirement.new(selector).satisfied_by?(::Gem::Version.new(RUBY_VERSION))
         end
 
         sig { params(src: String).returns(String) }
@@ -28,6 +31,14 @@ module Tapioca
 
           erb.result(binding)
         end
+
+        sig { params(str: String, indent: Integer).returns(String) }
+        def indented(str, indent)
+          str.lines.map! do |line|
+            next line if line.chomp.empty?
+            (" " * indent) + line
+          end.join
+        end
       end
     end
   end

data/lib/tapioca/internal.rb

@@ -2,20 +2,27 @@
 # frozen_string_literal: true
 
 require "tapioca"
-require "tapioca/loader"
+require "tapioca/runtime/reflection"
+require "tapioca/runtime/trackers"
+require "tapioca/runtime/dynamic_mixin_compiler"
+require "tapioca/runtime/loader"
 require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/fixed_hash_patch"
-require "tapioca/generic_type_registry"
+require "tapioca/runtime/generic_type_registry"
 require "tapioca/helpers/cli_helper"
 require "tapioca/helpers/config_helper"
-require "tapioca/generators"
+require "tapioca/helpers/rbi_helper"
+require "tapioca/helpers/shims_helper"
+require "tapioca/helpers/sorbet_helper"
+require "tapioca/commands"
 require "tapioca/cli"
 require "tapioca/gemfile"
 require "tapioca/executor"
-require "tapioca/compilers/sorbet"
-require "tapioca/compilers/requires_compiler"
-require "tapioca/compilers/symbol_table_compiler"
-require "tapioca/compilers/symbol_table/symbol_generator"
-require "tapioca/compilers/symbol_table/symbol_loader"
-require "tapioca/compilers/todos_compiler"
-require "tapioca/compilers/dsl_compiler"
+require "tapioca/static/symbol_table_parser"
+require "tapioca/static/symbol_loader"
+require "tapioca/gem/events"
+require "tapioca/gem/listeners"
+require "tapioca/gem/pipeline"
+require "tapioca/dsl/compiler"
+require "tapioca/dsl/pipeline"
+require "tapioca/static/requires_compiler"

data/lib/tapioca/rbi_ext/model.rb

@@ -1,59 +1,13 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "rbi"
-
 module RBI
-  class File
-    extend T::Sig
-
-    sig { returns(String) }
-    def transformed_string
-      transform_rbi!
-      string
-    end
-
-    sig { void }
-    def transform_rbi!
-      root.nest_singleton_methods!
-      root.nest_non_public_methods!
-      root.group_nodes!
-      root.sort_nodes!
-    end
-
-    sig do
-      params(
-        command: String,
-        reason: T.nilable(String),
-        display_heading: T::Boolean
-      ).void
-    end
-    def set_file_header(command, reason: nil, display_heading: true)
-      return unless display_heading
-      comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
-      comments << RBI::Comment.new("This is an autogenerated file for #{reason}.") unless reason.nil?
-      comments << RBI::Comment.new("Please instead update this file by running `#{command}`.")
-    end
-
-    sig { void }
-    def set_empty_body_content
-      comments << RBI::BlankLine.new unless comments.empty?
-      comments << RBI::Comment.new("THIS IS AN EMPTY RBI FILE.")
-      comments << RBI::Comment.new("see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires")
-    end
-
-    sig { returns(T::Boolean) }
-    def empty?
-      root.empty?
-    end
-  end
-
   class Tree
     extend T::Sig
 
     sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: Scope).void)).void }
     def create_path(constant, &block)
-      constant_name = Tapioca::Reflection.name_of(constant)
+      constant_name = Tapioca::Runtime::Reflection.name_of(constant)
       raise "given constant does not have a name" unless constant_name
 
       instance = ::Module.const_get(constant_name)
@@ -137,7 +91,7 @@ module RBI
 
     SPECIAL_METHOD_NAMES = T.let(
       ["!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^", "<", "<=", "=>", ">", ">=",
-       "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"].freeze,
+       "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",].freeze,
       T::Array[String]
     )
 

data/lib/tapioca/rbi_formatter.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  class RBIFormatter < RBI::Formatter
+    extend T::Sig
+
+    sig do
+      params(
+        file: RBI::File,
+        command: String,
+        reason: T.nilable(String)
+      ).void
+    end
+    def write_header!(file, command, reason: nil)
+      file.comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
+      file.comments << RBI::Comment.new("This is an autogenerated file for #{reason}.") unless reason.nil?
+      file.comments << RBI::Comment.new("Please instead update this file by running `#{command}`.")
+    end
+
+    sig { params(file: RBI::File).void }
+    def write_empty_body_comment!(file)
+      file.comments << RBI::BlankLine.new unless file.comments.empty?
+      file.comments << RBI::Comment.new("THIS IS AN EMPTY RBI FILE.")
+      file.comments << RBI::Comment.new("see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires")
+    end
+  end
+
+  DEFAULT_RBI_FORMATTER = T.let(RBIFormatter.new(
+    add_sig_templates: false,
+    group_nodes: true,
+    max_line_length: nil,
+    nest_singleton_methods: true,
+    nest_non_public_methods: true,
+    sort_nodes: true
+  ), RBIFormatter)
+end

data/lib/tapioca/runtime/dynamic_mixin_compiler.rb

@@ -0,0 +1,227 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    class DynamicMixinCompiler
+      extend T::Sig
+      include Runtime::Reflection
+
+      sig { returns(T::Array[Module]) }
+      attr_reader :dynamic_extends, :dynamic_includes
+
+      sig { returns(T::Array[Symbol]) }
+      attr_reader :class_attribute_readers, :class_attribute_writers, :class_attribute_predicates
+
+      sig { returns(T::Array[Symbol]) }
+      attr_reader :instance_attribute_readers, :instance_attribute_writers, :instance_attribute_predicates
+
+      sig { params(constant: Module).void }
+      def initialize(constant)
+        @constant = constant
+        mixins_from_modules = {}.compare_by_identity
+        class_attribute_readers = T.let([], T::Array[Symbol])
+        class_attribute_writers = T.let([], T::Array[Symbol])
+        class_attribute_predicates = T.let([], T::Array[Symbol])
+
+        instance_attribute_readers = T.let([], T::Array[Symbol])
+        instance_attribute_writers = T.let([], T::Array[Symbol])
+        instance_attribute_predicates = T.let([], T::Array[Symbol])
+
+        Class.new do
+          # Override the `self.include` method
+          define_singleton_method(:include) do |mod|
+            # Take a snapshot of the list of singleton class ancestors
+            # before the actual include
+            before = singleton_class.ancestors
+            # Call the actual `include` method with the supplied module
+            super(mod).tap do
+              # Take a snapshot of the list of singleton class ancestors
+              # after the actual include
+              after = singleton_class.ancestors
+              # The difference is the modules that are added to the list
+              # of ancestors of the singleton class. Those are all the
+              # modules that were `extend`ed due to the `include` call.
+              #
+              # We record those modules on our lookup table keyed by
+              # the included module with the values being all the modules
+              # that that module pulls into the singleton class.
+              #
+              # We need to reverse the order, since the extend order should
+              # be the inverse of the ancestor order. That is, earlier
+              # extended modules would be later in the ancestor chain.
+              mixins_from_modules[mod] = (after - before).reverse!
+            end
+          rescue Exception # rubocop:disable Lint/RescueException
+            # this is a best effort, bail if we can't perform this
+          end
+
+          define_singleton_method(:class_attribute) do |*attrs, **kwargs|
+            class_attribute_readers.concat(attrs)
+            class_attribute_writers.concat(attrs)
+
+            instance_predicate = kwargs.fetch(:instance_predicate, true)
+            instance_accessor = kwargs.fetch(:instance_accessor, true)
+            instance_reader = kwargs.fetch(:instance_reader, instance_accessor)
+            instance_writer = kwargs.fetch(:instance_writer, instance_accessor)
+
+            if instance_reader
+              instance_attribute_readers.concat(attrs)
+            end
+
+            if instance_writer
+              instance_attribute_writers.concat(attrs)
+            end
+
+            if instance_predicate
+              class_attribute_predicates.concat(attrs)
+
+              if instance_reader
+                instance_attribute_predicates.concat(attrs)
+              end
+            end
+
+            super(*attrs, **kwargs) if defined?(super)
+          end
+
+          # rubocop:disable Style/MissingRespondToMissing
+          T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
+          def method_missing(symbol, *args)
+            # We need this here so that we can handle any random instance
+            # method calls on the fake including class that may be done by
+            # the included module during the `self.included` hook.
+          end
+
+          class << self
+            extend T::Sig
+
+            T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
+            def method_missing(symbol, *args)
+              # Similarly, we need this here so that we can handle any
+              # random class method calls on the fake including class
+              # that may be done by the included module during the
+              # `self.included` hook.
+            end
+          end
+          # rubocop:enable Style/MissingRespondToMissing
+        end.include(constant)
+
+        # The value that corresponds to the original included constant
+        # is the list of all dynamically extended modules because of that
+        # constant. We grab that value by deleting the key for the original
+        # constant.
+        @dynamic_extends = T.let(mixins_from_modules.delete(constant) || [], T::Array[Module])
+
+        # Since we deleted the original constant from the list of keys, all
+        # the keys that remain are the ones that are dynamically included modules
+        # during the include of the original constant.
+        @dynamic_includes = T.let(mixins_from_modules.keys, T::Array[Module])
+
+        @class_attribute_readers = T.let(class_attribute_readers, T::Array[Symbol])
+        @class_attribute_writers = T.let(class_attribute_writers, T::Array[Symbol])
+        @class_attribute_predicates = T.let(class_attribute_predicates, T::Array[Symbol])
+
+        @instance_attribute_readers = T.let(instance_attribute_readers, T::Array[Symbol])
+        @instance_attribute_writers = T.let(instance_attribute_writers, T::Array[Symbol])
+        @instance_attribute_predicates = T.let(instance_attribute_predicates, T::Array[Symbol])
+      end
+
+      sig { returns(T::Boolean) }
+      def empty_attributes?
+        @class_attribute_readers.empty? && @class_attribute_writers.empty?
+      end
+
+      sig { params(tree: RBI::Tree).void }
+      def compile_class_attributes(tree)
+        return if empty_attributes?
+
+        # Create a synthetic module to hold the generated class methods
+        tree << RBI::Module.new("GeneratedClassMethods") do |mod|
+          class_attribute_readers.each do |attribute|
+            mod << RBI::Method.new(attribute.to_s)
+          end
+
+          class_attribute_writers.each do |attribute|
+            mod << RBI::Method.new("#{attribute}=") do |method|
+              method << RBI::Param.new("value")
+            end
+          end
+
+          class_attribute_predicates.each do |attribute|
+            mod << RBI::Method.new("#{attribute}?")
+          end
+        end
+
+        # Create a synthetic module to hold the generated instance methods
+        tree << RBI::Module.new("GeneratedInstanceMethods") do |mod|
+          instance_attribute_readers.each do |attribute|
+            mod << RBI::Method.new(attribute.to_s)
+          end
+
+          instance_attribute_writers.each do |attribute|
+            mod << RBI::Method.new("#{attribute}=") do |method|
+              method << RBI::Param.new("value")
+            end
+          end
+
+          instance_attribute_predicates.each do |attribute|
+            mod << RBI::Method.new("#{attribute}?")
+          end
+        end
+
+        # Add a mixes_in_class_methods and include for the generated modules
+        tree << RBI::MixesInClassMethods.new("GeneratedClassMethods")
+        tree << RBI::Include.new("GeneratedInstanceMethods")
+      end
+
+      sig { params(tree: RBI::Tree).returns([T::Array[Module], T::Array[Module]]) }
+      def compile_mixes_in_class_methods(tree)
+        includes = dynamic_includes.map do |mod|
+          qname = qualified_name_of(mod)
+
+          next if qname.nil? || qname.empty?
+          next if filtered_mixin?(qname)
+
+          tree << RBI::Include.new(qname)
+
+          mod
+        end.compact
+
+        # If we can generate multiple mixes_in_class_methods, then we want to use all dynamic extends that are not the
+        # constant itself
+        mixed_in_class_methods = dynamic_extends.select do |mod|
+          mod != @constant && !module_included_by_another_dynamic_extend?(mod, dynamic_extends)
+        end
+
+        return [[], []] if mixed_in_class_methods.empty?
+
+        mixed_in_class_methods.each do |mod|
+          qualified_name = qualified_name_of(mod)
+
+          next if qualified_name.nil? || qualified_name.empty?
+          next if filtered_mixin?(qualified_name)
+
+          tree << RBI::MixesInClassMethods.new(qualified_name)
+        end
+
+        [mixed_in_class_methods, includes]
+      rescue
+        [[], []] # silence errors
+      end
+
+      sig { params(mod: Module, dynamic_extends: T::Array[Module]).returns(T::Boolean) }
+      def module_included_by_another_dynamic_extend?(mod, dynamic_extends)
+        dynamic_extends.any? do |dynamic_extend|
+          mod != dynamic_extend && ancestors_of(dynamic_extend).include?(mod)
+        end
+      end
+
+      sig { params(qualified_mixin_name: String).returns(T::Boolean) }
+      def filtered_mixin?(qualified_mixin_name)
+        # filter T:: namespace mixins that aren't T::Props
+        # T::Props and subconstants have semantic value
+        qualified_mixin_name.start_with?("::T::") && !qualified_mixin_name.start_with?("::T::Props")
+      end
+    end
+  end
+end