Removed unnecessary methods from type checker

lib/Sema/TypeCheckExpr.cpp

@@ -6,40 +6,8 @@
 using namespace dusk;
 using namespace sema;
-bool TypeChecker::preWalkNumberLiteralExpr(NumberLiteralExpr *E) {
-  return false;
-}
-
-bool TypeChecker::preWalkIdentifierExpr(IdentifierExpr *E) {
-  return E->getType() == nullptr;
-}
-
-bool TypeChecker::preWalkParenExpr(ParenExpr *E) {
-  return E->getType() == nullptr;
-}
-
-bool TypeChecker::preWalkAssignExpr(AssignExpr *E) {
-  return E->getType() == nullptr;
-}
-
-bool TypeChecker::preWalkInfixExpr(InfixExpr *E) {
-  return E->getType() == nullptr;
-}
-
-bool TypeChecker::preWalkPrefixExpr(PrefixExpr *E) {
-  return E->getType() == nullptr;
-}
-
-bool TypeChecker::preWalkCallExpr(CallExpr *E) {
-  return E->getType() == nullptr;
-}
-
-bool TypeChecker::preWalkSubscriptExpr(SubscriptExpr *E) {
-  llvm_unreachable("Not implemented");
-}
-
 bool TypeChecker::postWalkNumberLiteralExpr(NumberLiteralExpr *E) {
-  llvm_unreachable("Not implemented");
+  return true;
 }
 bool TypeChecker::postWalkIdentifierExpr(IdentifierExpr *E) {

lib/Sema/TypeCheckStmt.cpp

@@ -16,23 +16,6 @@
 using namespace dusk;
 using namespace sema;
-
-bool TypeChecker::preWalkBreakStmt(BreakStmt *S) {
-  return true;
-}
-
-bool TypeChecker::preWalkReturnStmt(ReturnStmt *S) {
-  return true;
-}
-
-bool TypeChecker::preWalkRangeStmt(RangeStmt *S) {
-  return true;
-}
-
-bool TypeChecker::preWalkSubscriptStmt(SubscriptStmt *S) {
-  return true;
-}
-
 bool TypeChecker::preWalkBlockStmt(BlockStmt *S) {
   DeclCtx.push();
   if (auto Fn = dynamic_cast<FuncStmt *>(Scp.top().getStmt())) {

lib/Sema/TypeChecker.cpp

@@ -17,7 +17,8 @@
 using namespace dusk;
 using namespace sema;
-TypeChecker::TypeChecker(Sema &S, Context &C, ASTContext &Ctx, DiagnosticEngine &D)
+TypeChecker::TypeChecker(Sema &S, Context &C, ASTContext &Ctx,
+                         DiagnosticEngine &D)
     : S(S), DeclCtx(C), Ctx(Ctx), Diag(D) {
   Scp.push(Scope());
 }
@@ -53,24 +54,8 @@ bool TypeChecker::postWalk(Decl *D) {
 }
 bool TypeChecker::preWalk(Expr *E) {
-  switch (E->getKind()) {
-  case ExprKind::NumberLiteral:
-    return preWalkNumberLiteralExpr(static_cast<NumberLiteralExpr *>(E));
-  case ExprKind::Identifier:
-    return preWalkIdentifierExpr(static_cast<IdentifierExpr *>(E));
-  case ExprKind::Paren:
-    return preWalkParenExpr(static_cast<ParenExpr *>(E));
-  case ExprKind::Assign:
-    return preWalkAssignExpr(static_cast<AssignExpr *>(E));
-  case ExprKind::Infix:
-    return preWalkInfixExpr(static_cast<InfixExpr *>(E));
-  case ExprKind::Prefix:
-    return preWalkPrefixExpr(static_cast<PrefixExpr *>(E));
-  case ExprKind::Call:
-    return preWalkCallExpr(static_cast<CallExpr *>(E));
-  case ExprKind::Subscript:
-    return preWalkSubscriptExpr(static_cast<SubscriptExpr *>(E));
-  }
+  // Skip expression type validation tree if the root expression has a type.
+  return E->getType() == nullptr;
 }
 bool TypeChecker::postWalk(Expr *E) {
@@ -96,14 +81,6 @@ bool TypeChecker::postWalk(Expr *E) {
 bool TypeChecker::preWalk(Stmt *S) {
   switch (S->getKind()) {
-  case StmtKind::Break:
-    return preWalkBreakStmt(static_cast<BreakStmt *>(S));
-  case StmtKind::Return:
-    return preWalkReturnStmt(static_cast<ReturnStmt *>(S));
-  case StmtKind::Range:
-    return preWalkRangeStmt(static_cast<RangeStmt *>(S));
-  case StmtKind::Subscript:
-    return preWalkSubscriptStmt(static_cast<SubscriptStmt *>(S));
   case StmtKind::Block:
     return preWalkBlockStmt(static_cast<BlockStmt *>(S));
   case StmtKind::Extern:
@@ -116,6 +93,7 @@ bool TypeChecker::preWalk(Stmt *S) {
     return preWalkIfStmt(static_cast<IfStmt *>(S));
   case StmtKind::While:
     return preWalkWhileStmt(static_cast<WhileStmt *>(S));
+  default: return true;
   }
 }

lib/Sema/TypeChecker.h

@@ -66,15 +66,6 @@ private:
   bool postWalkVarDecl(VarDecl *D);
   // MARK: - Expressions
-  bool preWalkNumberLiteralExpr(NumberLiteralExpr *E);
-  bool preWalkIdentifierExpr(IdentifierExpr *E);
-  bool preWalkParenExpr(ParenExpr *E);
-  bool preWalkAssignExpr(AssignExpr *E);
-  bool preWalkInfixExpr(InfixExpr *E);
-  bool preWalkPrefixExpr(PrefixExpr *E);
-  bool preWalkCallExpr(CallExpr *E);
-  bool preWalkSubscriptExpr(SubscriptExpr *E);
-
   bool postWalkNumberLiteralExpr(NumberLiteralExpr *E);
   bool postWalkIdentifierExpr(IdentifierExpr *E);
   bool postWalkParenExpr(ParenExpr *E);
@@ -85,10 +76,6 @@ private:
   bool postWalkSubscriptExpr(SubscriptExpr *E);
   // MARK: - Statements
-  bool preWalkBreakStmt(BreakStmt *S);
-  bool preWalkReturnStmt(ReturnStmt *S);
-  bool preWalkRangeStmt(RangeStmt *S);
-  bool preWalkSubscriptStmt(SubscriptStmt *S);
   bool preWalkBlockStmt(BlockStmt *S);
   bool preWalkExternStmt(ExternStmt *S);
   bool preWalkForStmt(ForStmt *S);