Merge pull request #21 from philberty/phil/compilation-simple

WIP type infer error handling in LetStmt

Author: philberty

gcc/rust/analysis/rust-resolution.cc

@@ -1,9 +1,18 @@
 #include "rust-resolution.h"
+#include "rust-diagnostics.h"
 
 namespace Rust {
 namespace Analysis {
 
-TypeResolution::TypeResolution (AST::Crate &crate) : scope (), crate (crate) {}
+TypeResolution::TypeResolution (AST::Crate &crate) : scope (), crate (crate)
+{
+  // push all builtin types
+  // base is parse_path_ident_segment based up on segments
+  /*  scope.Insert ("u8",
+	      new AST::MaybeNamedParam (Identifier ("u8"),
+					AST::MaybeNamedParam::IDENTIFIER,
+					NULL, Location ()));*/
+}
 
 TypeResolution::~TypeResolution () {}
 
@@ -40,7 +49,9 @@ TypeResolution::visit (AST::AttrInputMetaItemContainer &input)
 
 void
 TypeResolution::visit (AST::IdentifierExpr &ident_expr)
-{}
+{
+  printf ("IdentifierExpr %s\n", ident_expr.as_string ().c_str ());
+}
 
 void
 TypeResolution::visit (AST::Lifetime &lifetime)
@@ -80,7 +91,11 @@ TypeResolution::visit (AST::QualifiedPathInType &path)
 // rust-expr.h
 void
 TypeResolution::visit (AST::LiteralExpr &expr)
-{}
+{
+  printf ("LiteralExpr: %s\n", expr.as_string ().c_str ());
+  // figure out what this type is and push it onto the
+}
+
 void
 TypeResolution::visit (AST::AttrInputLiteral &attr_input)
 {}
@@ -526,44 +541,70 @@ TypeResolution::visit (AST::SlicePattern &pattern)
 void
 TypeResolution::visit (AST::EmptyStmt &stmt)
 {}
-void
 
+void
 TypeResolution::visit (AST::LetStmt &stmt)
 {
-  printf ("Within LetStmt: %s\n", stmt.as_string ().c_str ());
-
-  if (!stmt.has_type ())
+  AST::Type *inferedType = NULL;
+  if (stmt.has_type ())
+    {
+      inferedType = stmt.type.get ();
+    }
+  else if (stmt.has_init_expr ())
     {
-      // infer the type
-      printf ("XXX UNKNOWN TYPE PLEASE INFER ME\n");
+      stmt.init_expr->accept_vis (*this);
+
+      if (typeBuffer.empty ())
+	{
+	  rust_error_at (
+	    stmt.init_expr->get_locus_slow (),
+	    "unable to determine type for declaration from init expr");
+	  return;
+	}
+
+      inferedType = typeBuffer.back ();
+      typeBuffer.pop_back ();
+    }
+  else
+    {
+      rust_error_at (stmt.locus, "unable to determine type for declaration");
+      return;
     }
 
   // TODO check we know what the type is
 
+  // get all the names part of this declaration and add the types to the scope
   stmt.variables_pattern->accept_vis (*this);
-
   for (auto it = letPatternBuffer.begin (); it != letPatternBuffer.end (); it++)
     {
-      scope.Insert (it->variable_ident, stmt.type.get ());
+      scope.Insert (it->variable_ident, inferedType);
     }
-
   letPatternBuffer.clear ();
 }
 
 void
 TypeResolution::visit (AST::ExprStmtWithoutBlock &stmt)
-{}
+{
+  printf ("ExprStmtWithoutBlock: %s\n", stmt.as_string ().c_str ());
+  stmt.expr->accept_vis (*this);
+}
+
 void
 TypeResolution::visit (AST::ExprStmtWithBlock &stmt)
-{}
+{
+  printf ("ExprStmtWithBlock: %s\n", stmt.as_string ().c_str ());
+  stmt.expr->accept_vis (*this);
+}
 
 // rust-type.h
 void
 TypeResolution::visit (AST::TraitBound &bound)
 {}
+
 void
 TypeResolution::visit (AST::ImplTraitType &type)
 {}
+
 void
 TypeResolution::visit (AST::TraitObjectType &type)
 {}

gcc/rust/analysis/rust-resolution.h

@@ -229,6 +229,7 @@ class TypeResolution : public AST::ASTVisitor
   AST::Crate &crate;
 
   std::vector<AST::IdentifierPattern> letPatternBuffer;
+  std::vector<AST::Type *> typeBuffer;
 };
 
 } // namespace Analysis

gcc/rust/ast/rust-stmt.h

@@ -147,14 +147,14 @@ class ExprStmt : public Stmt
  * difficulties, can only be guaranteed to hold an expression). */
 class ExprStmtWithoutBlock : public ExprStmt
 {
+public:
   // ExprWithoutBlock* expr;
   /* HACK: cannot ensure type safety of ExprWithoutBlock due to Pratt parsing,
    * so have to store more general type of Expr. FIXME: fix this issue somehow
    * or redesign AST. */
   //::std::unique_ptr<ExprWithoutBlock> expr;
   ::std::unique_ptr<Expr> expr;
 
-public:
   /*~ExpressionStatementWithoutBlock() {
       delete expr;
   }*/
@@ -201,10 +201,10 @@ class ExprStmtWithoutBlock : public ExprStmt
 // Statement containing an expression with a block
 class ExprStmtWithBlock : public ExprStmt
 {
+public:
   // ExprWithBlock* expr;
   ::std::unique_ptr<ExprWithBlock> expr;
 
-public:
   /*~ExpressionStatementWithBlock() {
       delete expr;
   }*/