Changeset 3835

Timestamp:

06/10/09 19:56:03 (5 months ago)

Author:

sukyoungryu

Message:

[type checker] Fixed small things in the Scala type checker. Matched some error messages from the Java type checker and the Scala type checker. Do not type check programs with syntax errors. Moved two tests from not_working_static_tests to compiler_tests.

Location:

trunk/ProjectFortress

Files:

• compiler_tests/Compiled1.j.fss (moved) (moved from trunk/ProjectFortress/not_working_static_tests/DXXDoubleExponentiation.fss) (1 diff)
• compiler_tests/Compiled1.k.fss (moved) (moved from trunk/ProjectFortress/not_working_static_tests/DXXExpThenSubscript.fss) (1 diff)
• compiler_tests/XXX1j.test (added)
• compiler_tests/XXX1k.test (added)
• src/com/sun/fortress/compiler/StaticChecker.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (2 diffs)
• src/com/sun/fortress/exceptions/FortressException.java (modified) (2 diffs)
• src/com/sun/fortress/scala_src/typechecker/STypeChecker.scala (modified) (10 diffs)

trunk/ProjectFortress/compiler_tests/Compiled1.j.fss

@@ -16 +16 @@
  ******************************************************************************)
 
-component DXXDoubleExponentiation
+component Compiled1.j
   export Executable
   run():() = ()

trunk/ProjectFortress/compiler_tests/Compiled1.k.fss

@@ -16 +16 @@
  ******************************************************************************)
 
-component DXXExpThenSubscript
+component Compiled1.k
   export Executable
   run():() = ()

trunk/ProjectFortress/src/com/sun/fortress/compiler/StaticChecker.java

@@ -222 +222 @@
                 ConstraintUtil.useScalaFormulas();
                 STypeChecker typeChecker = STypeCheckerFactory.make(component, traitTable, typeEnv, typeAnalyzer);
-                component_ast = typeChecker.check(component_ast);
+                component_ast = typeChecker.typecheck(component_ast);
                 component = IndexBuilder.builder.buildComponentIndex((Component)component_ast,
                     System.currentTimeMillis());

trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeChecker.java

@@ -432 +432 @@
                 }
                 else{
-                    String err_message = "Two consecutive ^s";
+                    String err_message = "Two consecutive ^s.";
                     StaticError err=TypeError.make(err_message,
-                                                                       new Span(NodeUtil.getSpan((ASTNode)exponent.unwrap()),
-                                                                                NodeUtil.getSpan(that)).toString());
+                                                   NodeUtil.getSpan(that).toString());
                     return new TypeCheckerResult(that,err);
                 }
@@ -446 +445 @@
                 }
                 else{
-                    String err_message = "Exponentiation followed by subscripting is illegal";
+                    String err_message = "Exponentiation followed by subscripting is illegal.";
                     StaticError err=TypeError.make(err_message,
-                                                                       new Span(NodeUtil.getSpan((ASTNode)exponent.unwrap()),
-                                                                                NodeUtil.getSpan(that)).toString());
+                                                   NodeUtil.getSpan(that).toString());
                     exponent = Option.none();
                     return new TypeCheckerResult(that,err);

trunk/ProjectFortress/src/com/sun/fortress/exceptions/FortressException.java

@@ -23 +23 @@
 import java.util.ArrayList;
 
+import edu.rice.cs.plt.tuple.Option;
 import com.sun.fortress.interpreter.evaluator.Environment;
 import com.sun.fortress.nodes_util.ErrorMsgMaker;
@@ -111 +112 @@
     public FortressException(Iterable<? extends StaticError> errors) {
         this.staticErrors = errors;
+    }
+
+    public Option<HasAt> getLoc() {
+        if ( this.where.isEmpty() )
+            return Option.none();
+        else return Option.wrap(this.where.get(0));
+    }
+
+    public String getOriginalMessage() {
+        return super.getMessage();
     }
 

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/STypeChecker.scala

@@ -44 +44 @@
 import com.sun.fortress.exceptions.StaticError
 import com.sun.fortress.exceptions.StaticError.errorMsg
-import com.sun.fortress.exceptions.TypeError
+import com.sun.fortress.exceptions.ProgramError
+import com.sun.fortress.exceptions.ProgramError.error
 import com.sun.fortress.nodes._
 import com.sun.fortress.nodes_util.NodeFactory
@@ -131 +132 @@
   protected def signal(hasAt:HasAt, msg:String) =
     errors.signal(msg, hasAt)
+
+  private def syntaxError(hasAt:HasAt, msg:String) =
+    error(hasAt, msg)
 
   /**
@@ -642 +646 @@
   // ------------------------------------------------------------------------
 
-
-  def check(node:Node):Node = node match {
+  def typecheck(node:Node):Node =
+    try { check(node) }
+    catch { case e:ProgramError =>
+              errors.errors = List[StaticError]()
+              errors.signal(e.getOriginalMessage, e.getLoc.unwrap)
+              node
+          }
+
+  private def check(node:Node):Node = node match {
     case SComponent(info, name, imports, decls, isNative, exports)  =>
       SComponent(info, name, imports,
@@ -1143 +1154 @@
           case SExponentiationMI(_,_,_) => exponent match {
             case None => exponent = Some(item)
-            case Some(e) => signal(item, "Two consecutive ^s.")
+            case Some(e) => syntaxError(item, "Two consecutive ^s.")
           }
           case SSubscriptingMI(_,_,_,_) => exponent match {
             case Some(e) =>
-              signal(item, "Exponentiation followed by subscripting is illegal.")
+              syntaxError(item, "Exponentiation followed by subscripting is illegal.")
             case None =>
           }
@@ -1169 +1180 @@
         case SParenthesisDelimitedMI(_,e) => isArrows(checkExpr(e))
         case SNonParenthesisDelimitedMI(_,e) => isArrows(checkExpr(e))
-        case _ =>
+        case _ => false
       }
       def expectParenedExprItem(item: MathItem) =
         if ( ! isParenedExprItem(item) )
-          signal(item, "Argument to function must be parenthesized.")
+          syntaxError(item, "Argument to function must be parenthesized.")
       def expectExprMI(item: MathItem) =
         if ( ! isExprMI(item) )
-          signal(item, "Item at this location must be an expression, not an operator.")
+          syntaxError(item, "Item at this location must be an expression, not an operator.")
       // items is not an empty list.
       def associateMathItems(first: Expr,
@@ -1188 +1199 @@
         // find the left-most function
         val (prefix, others) = items.span((e:MathItem) =>
-                                          !isFunctionItem(e).asInstanceOf[Boolean])
+                                          !isFunctionItem(e))
         others match {
           case fn::arg::suffix => arg match {
             // It is a static error if either the argument is not parenthesized,
             case SNonParenthesisDelimitedMI(_,e) =>
-              signal(e, "Tightly juxtaposed expression should be parenthesized.")
+              syntaxError(e, "Tightly juxtaposed expression should be parenthesized.")
               (first, Nil)
             case SParenthesisDelimitedMI(i,e) => {
@@ -1200 +1211 @@
                 case third::more =>
                   if ( ! isExprMI(third) )
-                    signal(third, "An expression is expected.")
+                    syntaxError(third, "An expression is expected.")
                 case _ =>
               }
@@ -1227 +1238 @@
               left.last.asInstanceOf[ExprMI].getExpr
             else {
-              signal(left.last, "An expression is expected.")
+              syntaxError(left.last, "An expression is expected.")
               first
             }
@@ -1248 +1259 @@
                                               toJavaList(sargs))
               case _ =>
-                signal(item, "Non-expression element is expected.")
+                syntaxError(item, "Non-expression element is expected.")
                 head
             }
@@ -1289 +1300 @@
             val newTail = tail.map( (e:MathItem) =>
                                     if ( ! isExprMI(e) ) {
-                                      signal(e, "An expression is expected.")
+                                      syntaxError(e, "An expression is expected.")
                                       ExprFactory.makeVoidLiteralExpr(span)
                                     } else e.asInstanceOf[ExprMI].getExpr )