1 files changed, 102 insertions, 0 deletions
diff --git a/src/hir/hir.cpp b/src/hir/hir.cpp
index 5b9401f5..bc1fecd5 100644
--- a/src/hir/hir.cpp
+++ b/src/hir/hir.cpp
@@ -28,3 +28,105 @@ namespace HIR {
         return os;
     }
 }
+
+namespace {
+    bool matches_type_int(const ::HIR::GenericParams& params, const ::HIR::TypeRef& left,  const ::HIR::TypeRef& right)
+    {
+        assert(! left.m_data.is_Infer() );
+        if( right.m_data.is_Infer() ) {
+            return false;
+        }
+        
+        if( left.m_data.is_Generic() ) {
+            // True?
+            return true;
+        }
+        
+        if( left.m_data.tag() != right.m_data.tag() ) {
+            return false;
+        }
+        TU_MATCH(::HIR::TypeRef::Data, (left.m_data, right.m_data), (le, re),
+        (Infer, assert(!"infer");),
+        (Diverge, return true; ),
+        (Primitive, return le == re;),
+        (Path,
+            if( le.m_data.tag() != re.m_data.tag() )
+                return false;
+            TU_MATCH_DEF(::HIR::Path::Data, (le.m_data, re.m_data), (ple, pre),
+            (
+                return false;
+                ),
+            (Generic,
+                if( ple.m_path.m_crate_name != pre.m_path.m_crate_name )
+                    return false;
+                if( ple.m_path.m_components.size() != pre.m_path.m_components.size() )
+                    return false;
+                for(unsigned int i = 0; i < ple.m_path.m_components.size(); i ++ )
+                {
+                    if( ple.m_path.m_components[i] != pre.m_path.m_components[i] )
+                        return false;
+                }
+                
+                if( ple.m_params.m_types.size() > 0 || pre.m_params.m_types.size() > 0 ) {
+                    TODO(Span(), "Match paths " << ple << " and " << pre);
+                }
+                return true;
+                )
+            )
+            ),
+        (Generic,
+            throw "";
+            ),
+        (TraitObject,
+            DEBUG("TODO: Compare " << left << " and " << right);
+            return false;
+            ),
+        (Array,
+            if( ! matches_type_int(params, *le.inner, *re.inner) )
+                return false;
+            if( le.size_val != re.size_val )
+                return false;
+            return true;
+            ),
+        (Slice,
+            return matches_type_int(params, *le.inner, *re.inner);
+            ),
+        (Tuple,
+            if( le.size() != re.size() )
+                return false;
+            for( unsigned int i = 0; i < le.size(); i ++ )
+                if( !matches_type_int(params, le[i], re[i]) )
+                    return false;
+            return true;
+            ),
+        (Borrow,
+            if( le.type != re.type )
+                return false;
+            return matches_type_int(params, *le.inner, *re.inner);
+            ),
+        (Pointer,
+            if( le.is_mut != re.is_mut )
+                return false;
+            return matches_type_int(params, *le.inner, *re.inner);
+            ),
+        (Function,
+            DEBUG("TODO: Compare " << left << " and " << right);
+            return false;
+            )
+        )
+        return false;
+    }
+}
+
+bool ::HIR::TraitImpl::matches_type(const ::HIR::TypeRef& type) const
+{
+    return matches_type_int(m_params, m_type, type);
+}
+bool ::HIR::TypeImpl::matches_type(const ::HIR::TypeRef& type) const
+{
+    return matches_type_int(m_params, m_type, type);
+}
+bool ::HIR::MarkerImpl::matches_type(const ::HIR::TypeRef& type) const
+{
+    return matches_type_int(m_params, m_type, type);
+}