Merge branch 'reachabilityCheck' into 'master'

implemented reachability checking. passing 56 test cases locally

See merge request !8

AST.py

@@ -68,28 +68,10 @@ class ASTNode():
             if c and hasattr(c, 'checkType'):
                 c.checkType()
 
-    def staticAnalysis(self):
-        for c in self.children:
-            if c and hasattr(c, 'staticAnalysis'):
-                c.staticAnalysis()
-
-    # return outMaybe
-    def reachCheck(self, inMaybe = True):
-        if inMaybe == False:
-            # error if in[s] = no for any s
-            # I don't think it should get to here... but maybe?
-            raise Exception("in[s] = no for a certain {}".format(type(self)))
-    
-        self.inMaybe = inMaybe
-        self.outMaybe = self.inMaybe
-        lastOut = self.inMaybe
-
+    def reachCheck(self, inMaybe=True):
         for c in self.children:
             if c and hasattr(c, 'reachCheck'):
-                lastOut = c.reachCheck(lastOut)
-                self.outMaybe = self.outMaybe and lastOut
-
-        return self.outMaybe
+                c.reachCheck(inMaybe)
 
     def printNodePretty(self, prefix=0):
         pp = pprint.PrettyPrinter(indent=prefix)

AstBuilding.py

@@ -49,13 +49,8 @@ def disamiguateAndTypeChecking(ASTs):
     for t in ASTs:
         t[1].checkType()
 
-    # resolving the rest of the name
-
 #######################################################
 
 def reachabilityChecking(ASTs):
     for t in ASTs:
-        t[1].reachCheck()
-
+        t[1].reachCheck()
\ No newline at end of file
-    # for t in ASTs:
-    #     t[1].staticAnalysis()

ExprPrimaryNodes.py

@@ -224,6 +224,11 @@ class AssignNode(ASTNode):
 
         raise Exception("ERROR: assignment operation failed. Cannot assign type {0} to type {1} at class {2}".format(self.left.myType.name, self.right.myType.name, self.typeName))
 
+    def reachCheck(self, inMaybe):
+        if not inMaybe:
+            raise Exception("ERROR: not reaching a assignment statement")
+        self.outMaybe = inMaybe
+
 
 ##################################################################################
 # cast: castExpr LPAREN castType RPAREN unaryNotPlusMinus
@@ -574,6 +579,11 @@ class MethodInvNode(ASTNode):
         else:
 
             raise Exception("ERROR: Class {} doesn't have a method {} with given argument types.".format(self.typeName, self.ID.name))
+            
+    def reachCheck(self, inMaybe):
+        if not inMaybe:
+            raise Exception("ERROR: not reaching a variable declaration statement for var {}".format(self.name))
+        self.outMaybe = inMaybe
 
 ################# Helper #######################
 

LineNodes.py

@@ -88,6 +88,23 @@ class BlockNode(ASTNode):
         self.env = env
         return self.env
 
+    def reachCheck(self, inMaybe):
+        self.inMaybe = inMaybe
+
+        if not self.inMaybe:
+            raise Exception("ERROR: cannot reach block node in class {}".format(self.typeName))
+        
+        # Checking reachability of each statement
+        prevOut = self.inMaybe # Note: in[S1] = in[L]
+        for statement in self.statements:
+            if statement:
+                statement.reachCheck(prevOut)
+                prevOut = statement.outMaybe
+            else: # checking for empty statements
+                if not prevOut:
+                    raise Exception("ERROR: empty statement is unreachable at block node for class {}".format(self.typeName))
+        self.outMaybe = prevOut
+        return
 
 # variableDcl
 # Rules:
@@ -113,12 +130,12 @@ class VarDclNode(ASTNode):
         # Checking for definite assignment
         if checkAssign:
             if not self.variableInit:
-                raise Exception("ERROR: local variable declaration {} is not assigned".format(self.name))
+                raise Exception("ERROR: local variable declaration {} is not assigned in class {}".format(self.name, self.typeName))
             # Checking if the local variable appears in it's own intializer
             nameNodes = getASTNode(["NameNode"], self.variableInit)
             for node in nameNodes:
                 if self.name in node.IDs:
-                    raise Exception("ERROR: local variable {} appears in it's own intialization".format(self.name))
+                    raise Exception("ERROR: local variable {} appears in it's own intialization in class {}".format(self.name, self.typeName))
 
         self.myType = self.dclType.myType
         self.children.append(self.dclType)
@@ -140,6 +157,10 @@ class VarDclNode(ASTNode):
             if not self.myType.assignable(self.variableInit.myType):
                 raise Exception("ERROR: Cannot initialize variable of type {} with type {}".format(self.myType.name, self.variableInit.myType.name))
 
+    def reachCheck(self, inMaybe):
+        if not inMaybe:
+            raise Exception("ERROR: not reaching a variable declaration statement for var {} in class {}".format(self.name, self.typeName))
+        self.outMaybe = inMaybe
 
 # ifStatement, ifElseStatement, ifElseStatementNoShortIf
 # Rules:
@@ -174,26 +195,31 @@ class IfNode(ASTNode):
         if self.elseBody:
             self.elseBody.checkType()
 
-    def reachCheck(self, inMaybe = True):
-        if inMaybe == False:
-            # error if in[s] = no for any s
+    def reachCheck(self, inMaybe):
+        if not inMaybe:
             raise Exception("in[s] = no for IfNode in class {}".format(self.typeName))
 
-        self.inMaybe = inMaybe
-        s1 = self.ifBody.reachCheck(self.inMaybe)
+        # No need to check for empty statement, since in[ifBody] = inMaybe
+        if self.ifBody:
+            self.ifBody.reachCheck(inMaybe)
+        
         if not self.elseBody:
             # L : if (E) S
             # in[S] = in[L]
             # out[L] = in[L]
-            self.outMaybe = self.inMaybe
+            self.outMaybe = inMaybe
         else:
             # L : if (E) S1 else S2
             # in[S1] = in[L]
             # in[S2] = in[L]
             # out[L] = out[S1] V out[S2]
-            s2 = self.elseBody.reachCheck(self.inMaybe)
-            self.outMaybe = s1 or s2
-        return self.outMaybe
+            if self.elseBody:
+                self.elseBody.reachCheck(inMaybe)
+                self.outMaybe = (self.ifBody.outMaybe or self.elseBody.outMaybe)
+            else:
+                # no need to check reachability for empty elseBody, since in[elseBody] = in[L]
+                self.outMaybe = self.ifBody.outMaybe
+
 
 # whileStatement, whileStatementNoShortIf
 # Rules:
@@ -215,30 +241,42 @@ class WhileNode(ASTNode):
         self.children.append(self.whileBody)
 
     def checkType(self):
-        self.whileBound.checkType()
-        if self.whileBound.myType.name != 'boolean':
-            raise Exception("ERROR: Cannot use non-boolean type for whileBound.")
-        self.whileBody.checkType()
-
-    def staticAnalysis(self):
-        # check constant expr
+        if self.whileBound:
+            self.whileBound.checkType()
+            if self.whileBound.myType.name != 'boolean':
+                raise Exception("ERROR: Cannot use non-boolean type for whileBound.")
+        if self.whileBody:
+            self.whileBody.checkType()
+
+    def reachCheck(self, inMaybe):
+        if not inMaybe:
+            raise Exception("in[s] = no for WhileNode in class {}".format(self.typeName))
+        
+        # Checking constant expression in whileBound
+        con = None # default to None: i.e. not a constant expression
         if hasattr(self.whileBound, "getConstant"):
             con = self.whileBound.getConstant()
 
-            if con != None:
-                print(con, self.whileBound.typeName)
-
-    def reachCheck(self, inMaybe = True):
-        if inMaybe == False:
-            # error if in[s] = no for any s
-            raise Exception("in[s] = no for WhileNode in class {}".format(self.typeName))
-
-        # L : while (E) S
-        # in[S] = in[L]
-        # out[L] = in[L]
-        self.inMaybe = inMaybe
-        self.whileBound.reachCheck(self.inMaybe)
-        self.outMaybe = self.inMaybe
+        # Setting self.outMaybe
+        inMaybeWhileBody = inMaybe # the input to reachCheck on whileBody
+        # General case: while(E) S
+        if con == None:
+            self.outMaybe = inMaybe
+        # while(false) S 
+        elif con == False or con == 0:
+            self.outMaybe = inMaybe
+            inMaybeWhileBody = False
+        else: # either an integer that's not zero or True
+            self.outMaybe = False
+
+        # Checking reachability on whileBody
+        if self.whileBody:
+            self.whileBody.reachCheck(inMaybeWhileBody) 
+        elif not inMaybeWhileBody: # empty block/empty statement that's unreachable
+            raise Exception("ERROR: unreachable empty statment/block at while node for class {}".format(self.typeName))
+
+        return
+        
 
 # returnStatement
 # Rules:
@@ -268,16 +306,10 @@ class ReturnNode(ASTNode):
         else:
             self.myType = None # this is None as returning a value of type Void is invalid even in a function with type Void
 
-    def reachCheck(self, inMaybe = True):
-        if inMaybe == False:
-            # error if in[s] = no for any s
-            raise Exception("in[s] = no for ReturnNode in class {}".format(self.typeName))
-
-        # L : return, L : return E
-        # out[L] = no
-        self.inMaybe = inMaybe
-        self.outMaybe = False
-        return self.outMaybe
+    def reachCheck(self, inMaybe):
+        if not inMaybe:
+            raise Exception("ERROR: return statement unreachable at class {}".format(self.typeName))
+        self.outMaybe = False # out[L] = no
 
 # forStatement and forStatementNoShortIf
 # Rules:
@@ -342,9 +374,30 @@ class ForNode(ASTNode):
         self.forUpdate.checkType()
         self.bodyStatement.checkType()
 
-    def staticAnalysis(self):
-        # check constant expr
+    def reachCheck(self, inMaybe):
+        if not inMaybe:
+            raise Exception("in[s] = no for ForNode in class {}".format(self.typeName))
+        
+        # Checking constant expression in whileBound
+        con = None # default to None: i.e. not a constant expression
         if hasattr(self.forBound, "getConstant"):
             con = self.forBound.getConstant()
-            if con != None:
-                print(con, self.whileBound.typeNam)
+
+        # Setting self.outMaybe
+        inMaybeForBody = inMaybe # the input to reachCheck on bodyStatement
+        # General case
+        if con == None:
+            self.outMaybe = inMaybe
+        # for(false) S
+        elif con == False or con == 0:
+            self.outMaybe = inMaybe
+            inMaybeForBody = False
+        else: # either an integer that's not zero or True
+            self.outMaybe = False
+
+        # Checking reachability on whileBody
+        if self.bodyStatement:
+            self.bodyStatement.reachCheck(inMaybeForBody)  
+        elif inMaybeForBody: # checking if the empty forBody can be reached
+            raise Exception("ERROR: unreachable empty statement/block at for node at class {}".format(self.typeName)) 
+        return

MemberNodes.py

@@ -169,19 +169,22 @@ class MethodNode(ASTNode):
                 raise Exception("ERROR: return type of function {} doesn't match with return statement.".format(self.name))
         return
 
-    def reachCheck(self, inMaybe = True):
-        # self.inMaybe is always true for methods
-        self.inMaybe = True
+    def reachCheck(self, inMaybe=True):
         self.outMaybe = False
 
+        # Check reachability of method body
+        # No need to check for empty function body, since the check is done in checkType
         if self.body:
-            self.outMaybe = self.body.reachCheck()
+            self.body.reachCheck(True) # For method bodies, in[L] = maybe by default
+            self.outMaybe = self.body.outMaybe
+        
 
-        # error if out[(non-void) method body] = maybe
-        # self.methodType is an empty string if it's a constructor
-        if type(self.methodType) != str and self.methodType.myType.name != "void" and self.outMaybe == True:
+        # Check if out[method body] is a maybe for non-void methods 
+        if not self.methodType or self.myType.name == "void":  # Omitting the check for constructors and void functions
+            return
+        if self.outMaybe:
             raise Exception("Non-void method '{}' in class '{}' does not return".format(self.name, self.typeName))
-        return self.outMaybe
+        return
 
 ############# helper for forward ref checking ########
 # Input: AST Node

Test.py

@@ -158,7 +158,6 @@ def run(testFiles):
         disamiguateAndTypeChecking(ASTs)
     except Exception as e:
         return "disamiguateAndTypeChecking: " + e.args[0]
-    
     try:
         reachabilityChecking(ASTs)
     except Exception as e: