AST - Support ! as a real type

8 files changed, 50 insertions, 27 deletions

diff --git a/src/ast/types.cpp b/src/ast/types.cpp
index 070f02ba..ba2c12f2 100644
--- a/src/ast/types.cpp
+++ b/src/ast/types.cpp
@@ -111,6 +111,7 @@ TypeRef::TypeRef(const TypeRef& other)
     #define _CLONE(VAR, code...)    case TypeData::TAG_##VAR: { auto& old = other.m_data.as_##VAR(); m_data = TypeData::make_##VAR(code); } break;
     _COPY(None)
     _COPY(Any)
+    _COPY(Bang)
     case TypeData::TAG_Macro:   assert( !"Copying an unexpanded type macro" );
     _COPY(Unit)
     _COPY(Primitive)
@@ -139,6 +140,7 @@ Ordering TypeRef::ord(const TypeRef& x) const
     (Macro, throw CompileError::BugCheck("TypeRef::ord - unexpanded macro");),
     (Any,  return OrdEqual;),
     (Unit, return OrdEqual;),
+    (Bang, return OrdEqual;),
     (Primitive,
         return ::ord( (unsigned)ent.core_type, (unsigned)x_ent.core_type );
         ),
@@ -191,11 +193,14 @@ Ordering TypeRef::ord(const TypeRef& x) const
     {
     case TypeData::TAGDEAD: throw "";
     _(None,
-        os << "!";
+        os << "!!";
         )
     _(Any,
         os << "_";
         )
+    _(Bang,
+        os << "!";
+        )
     _(Macro,
         os << ent.inv;
         )
@@ -307,6 +312,7 @@ SERIALISE_TYPE(TypeRef::, "TypeRef", {
         s.item( ent.inv );
         )
     _S(Any)
+    _S(Bang)
     _S(Unit)
     _S(Primitive,
         s << coretype_name(ent.core_type);
@@ -353,6 +359,7 @@ SERIALISE_TYPE(TypeRef::, "TypeRef", {
     _D(None)
     _D(Any)
     _D(Unit)
+    _D(Bang)
     _D(Macro,
         m_data = TypeData::make_Macro({});
         s.item( ent.inv );
diff --git a/src/ast/types.hpp b/src/ast/types.hpp
index 8fbd6c37..1710fceb 100644
--- a/src/ast/types.hpp
+++ b/src/ast/types.hpp
@@ -61,6 +61,7 @@ struct Type_Function:
 TAGGED_UNION(TypeData, None,

     (None, struct { }),

     (Any,  struct { }),

+    (Bang, struct { }),

     (Unit, struct { }),

     (Macro, struct {

         ::AST::MacroInvocation inv;

@@ -126,9 +127,13 @@ public:
         return *this;

     }

     

-    TypeRef(Span sp=Span()):

+    TypeRef(Span sp = Span()):

         m_span( mv$(sp) ),

-        m_data(TypeData::make_Any({}))

+        m_data( TypeData::make_Any({}) )

+    {}

+    TypeRef(Span sp, TypeData data):

+        m_span( mv$(sp) ),

+        m_data( mv$(data) )

     {}

     

     struct TagInvalid {};

@@ -136,7 +141,7 @@ public:
         m_span(mv$(sp)),

         m_data(TypeData::make_None({}))

     {}

-    

+

     struct TagMacro {};

     TypeRef(TagMacro, ::AST::MacroInvocation inv):

         m_span(inv.span()),

diff --git a/src/expand/derive.cpp b/src/expand/derive.cpp
index f14e7ae8..310ad104 100644
--- a/src/expand/derive.cpp
+++ b/src/expand/derive.cpp
@@ -129,6 +129,8 @@ struct Deriver
             ),
         (Unit,
             ),
+        (Bang,
+            ),
         (Macro,
             // not allowed
             ),
diff --git a/src/expand/mod.cpp b/src/expand/mod.cpp
index d4c117b1..3fb0c648 100644
--- a/src/expand/mod.cpp
+++ b/src/expand/mod.cpp
@@ -191,6 +191,8 @@ void Expand_Type(bool is_early, ::AST::Crate& crate, LList<const AST::Module*> m
         ),
     (Unit,
         ),
+    (Bang,
+        ),
     (Macro,
         auto tt = Expand_Macro(is_early, crate, modstack, mod,  e.inv);
         TODO(e.inv.span(), "Expand macro invocation in type");
diff --git a/src/hir/from_ast.cpp b/src/hir/from_ast.cpp
index 90ab5c2a..f001b081 100644
--- a/src/hir/from_ast.cpp
+++ b/src/hir/from_ast.cpp
@@ -577,6 +577,9 @@ const ::HIR::SimplePath path_Sized = ::HIR::SimplePath("", {"marker", "Sized"});
 {
     TU_MATCH(::TypeData, (ty.m_data), (e),
     (None,
+        BUG(ty.span(), "TypeData::None");
+        ),
+    (Bang,
         // Aka diverging
         return ::HIR::TypeRef( ::HIR::TypeRef::Data::make_Diverge({}) );
         ),
@@ -587,7 +590,7 @@ const ::HIR::SimplePath path_Sized = ::HIR::SimplePath("", {"marker", "Sized"});
         return ::HIR::TypeRef( ::HIR::TypeRef::Data::make_Tuple({}) );
         ),
     (Macro,
-        BUG(ty.span(), "TypeData::None");
+        BUG(ty.span(), "TypeData::Macro");
         ),
     (Primitive,
         switch(e.core_type)
@@ -1012,7 +1015,6 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
     for( const auto& impl : ast_mod.impls() )
     {
         auto params = LowerHIR_GenericParams(impl.def().params(), nullptr);
-        auto type = LowerHIR_Type(impl.def().type());
         
         if( impl.def().trait().ent.is_valid() )
         {
@@ -1022,19 +1024,10 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
             auto trait_name = mv$(trait_path.m_path);
             auto trait_args = mv$(trait_path.m_params);
             
-            if( is_marker )
-            {
-                hir_crate.m_marker_impls.insert( ::std::make_pair( mv$(trait_name), ::HIR::MarkerImpl {
-                    mv$(params),
-                    mv$(trait_args),
-                    true,
-                    mv$(type),
-                    
-                    LowerHIR_SimplePath(Span(), ast_mod.path())
-                    } ) );
-            }
-            else
+            if( !is_marker )
             {
+                auto type = LowerHIR_Type(impl.def().type());
+                
                 ::HIR::ItemPath    path(type, trait_name);
                 DEBUG(path);
                 
@@ -1073,10 +1066,27 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
                     LowerHIR_SimplePath(Span(), ast_mod.path())
                     }) );
             }
+            else if( impl.def().type().m_data.is_None() )
+            {
+                // Ignore - These are encoded in the 'is_marker' field of the trait
+            }
+            else
+            {
+                auto type = LowerHIR_Type(impl.def().type());
+                hir_crate.m_marker_impls.insert( ::std::make_pair( mv$(trait_name), ::HIR::MarkerImpl {
+                    mv$(params),
+                    mv$(trait_args),
+                    true,
+                    mv$(type),
+                    
+                    LowerHIR_SimplePath(Span(), ast_mod.path())
+                    } ) );
+            }
         }
         else
         {
             // Inherent impls
+            auto type = LowerHIR_Type(impl.def().type());
             ::HIR::ItemPath    path(type);
             ::std::map< ::std::string, ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> > methods;
             
diff --git a/src/parse/root.cpp b/src/parse/root.cpp
index c21cfba3..1ee1a13d 100644
--- a/src/parse/root.cpp
+++ b/src/parse/root.cpp
@@ -372,13 +372,7 @@ AST::Function Parse_FunctionDef(TokenStream& lex, ::std::string abi, AST::MetaIt
     if( GET_TOK(tok, lex) == TOK_THINARROW )

     {

         // Return type

-        if( GET_TOK(tok, lex) == TOK_EXCLAM ) {

-            ret_type = TypeRef(TypeRef::TagInvalid(), Span(tok.get_pos()));

-        }

-        else {

-            PUTBACK(tok, lex);

-            ret_type = Parse_Type(lex);

-        }

+        ret_type = Parse_Type(lex);

     }

     else

     {

diff --git a/src/parse/types.cpp b/src/parse/types.cpp
index 34afc484..d960d1d3 100644
--- a/src/parse/types.cpp
+++ b/src/parse/types.cpp
@@ -40,7 +40,7 @@ TypeRef Parse_Type_Int(TokenStream& lex, bool allow_trait_list)
         return TypeRef(TypeRef::TagMacro(), Parse_MacroInvocation(ps, AST::MetaItems(), mv$(tok.str()), lex));
     // '!' - Only ever used as part of function prototypes, but is kinda a type... not allowed here though
     case TOK_EXCLAM:
-        throw ParseError::Generic(lex, "! is not a real type");
+        return TypeRef( Span(tok.get_pos()), TypeData::make_Bang({}) );
     // '_' = Wildcard (type inferrence variable)
     case TOK_UNDERSCORE:
         return TypeRef(Span(tok.get_pos()));
diff --git a/src/resolve/absolute.cpp b/src/resolve/absolute.cpp
index 0a0cf478..89a16d47 100644
--- a/src/resolve/absolute.cpp
+++ b/src/resolve/absolute.cpp
@@ -878,13 +878,16 @@ void Resolve_Absolute_Type(Context& context,  TypeRef& type)
     const auto& sp = type.span();
     TU_MATCH(TypeData, (type.m_data), (e),
     (None,
-        // ! type
+        // invalid type
         ),
     (Any,
         // _ type
         ),
     (Unit,
         ),
+    (Bang,
+        // ! type
+        ),
     (Macro,
         BUG(sp, "Resolve_Absolute_Type - Encountered an unexpanded macro");
         ),