Only allow negating booleans.

spec/formatters/negated_expression

@@ -1,11 +1,11 @@
 module Test {
   fun test : Bool {
-    !!!!!"fun" && !!!![1] && !1
+    !!!!!true && !!!!false && !false
   }
 }
 --------------------------------------------------------------------------------
 module Test {
   fun test : Bool {
-    !"fun" && !![1] && !1
+    !true && !!false && !false
   }
 }

spec/type_checking/negated_expression

@@ -0,0 +1,11 @@
+module Test {
+  fun test : Bool {
+    !false
+  }
+}
+--------------------------------------------------------NegatedExpressionNotBool
+module Test {
+  fun test : Bool {
+    !"asd"
+  }
+}

src/formatters/negated_expression.cr

@@ -3,6 +3,7 @@ module Mint
     def format(node : Ast::NegatedExpression) : String
       expression =
         format node.expression
+
       "#{node.negations}#{expression}"
     end
   end

src/messages/negated_expression_not_bool.cr

@@ -0,0 +1,11 @@
+message NegatedExpressionNotBool do
+  title "Type Error"
+
+  block do
+    text "A negated expressions expression must evaluate to bool."
+  end
+
+  was_expecting_type expected, got
+
+  snippet node
+end

src/type_checkers/negated_expression.cr

@@ -1,7 +1,17 @@
 module Mint
   class TypeChecker
+    type_error NegatedExpressionNotBool
+
     def check(node : Ast::NegatedExpression) : Type
-      BOOL
+      expression =
+        check node.expression
+
+      raise NegatedExpressionNotBool, {
+        "got"      => expression,
+        "expected" => BOOL,
+      } unless Comparer.compare(BOOL, expression)
+
+      expression
     end
   end
 end