centralize class & interface logic

TypeNodes.py

@@ -4,8 +4,61 @@ from Environment import Env
 
 # types: class , interface
 
+class ClassInterNode(ASTNode):    
+    def checkHierarchy(self):
+        # 3. An interface must not be repeated in an implements clause
+        if self.superInter:
+            unique = []
+            for inter in self.superInter:
+                if inter.name in unique:
+                    raise Exception("ERROR: Class/Interface '{}' implements duplicate interfaces '{}'".format(self.name, inter.name))
+                unique.append(inter.name)
+        
+        # 7. A class or interface must not declare two methods with the same signature (name and parameter types).
+        unique = []
+        for method in self.methods:
+            key = (method.name, method.paramTypes)
+            if key in unique:
+                raise Exception("ERROR: Class/Interface '{}' declares 2 methods with the same signature '{}'".format(self.name, key[0]))
+            unique.append(key)
+        
+        # 6. The hierarchy must be acyclic
+        # 9. A class or interface must not contain (declare or inherit) two methods with the same signature but different return types
+        # 11. A nonstatic method must not replace a static method
+        # 13. A protected method must not replace a public method
+        # 14. A method must not replace a final method
+        return self.getContains([])
+
+    def getContains(self, hierarchy):        
+        # check if not acyclic
+        if self.name in hierarchy:
+            raise Exception("ERROR: The hierarchy is not acyclic '{}', saw '{}'".format(hierarchy, self.name))
+        hierarchy.append(self.name)
+
+        # get contains
+        contains = self.methods
+        
+        for inter in self.superInter:
+            superContains = inter.getContains(hierarchy)
+            for con in superContains:
+                conOverwritten = False
+                for method in self.methods:
+                    if (method == con):
+                        # cannot have same signiture but different return types
+                        if (method.methodType != con.methodType):
+                            raise Exception("ERROR: Class '{}' contains 2 methods '{}' with the same signature but different return types".format(self.name, method.name))
+                        # protected must not replace public
+                        if 'protected' in method.mods and 'public' in con.mods:
+                            raise Exception("ERROR: Protected method '{}' in class '{}' replaces public method '{}' in class {}".format(method.name, self.name, con.name, inter.name))
+                        conOverwritten = True
+                        break
+                if not conOverwritten:
+                    contains.append(con)
+        
+        return contains
+
 # class
-class ClassNode(ASTNode):
+class ClassNode(ClassInterNode):
     # always list all fields in the init method to show the class structure
     def __init__(self, parseTree):
         self.parseTree = parseTree
@@ -88,17 +141,7 @@ class ClassNode(ASTNode):
             for inter in self.superInter:
                 if not isinstance(inter, InterNode):
                     raise Exception("ERROR: Class '{}' implements non-interface '{}'".format(self.name, inter.name))
-                if inter.name in unique:
-                    raise Exception("ERROR: Class '{}' implements duplicate interfaces '{}'".format(self.name, inter.name))
                 unique.append(inter.name)
-        
-        # 7. A class or interface must not declare two methods with the same signature (name and parameter types).
-        unique = []
-        for method in self.methods:
-            key = (method.name, method.paramTypes)
-            if key in unique:
-                raise Exception("ERROR: Class '{}' declares 2 methods with the same signature '{}'".format(self.name, key[0]))
-            unique.append(key)
 
         # 8. A class must not declare two constructors with the same parameter types
         unique = []
@@ -108,12 +151,9 @@ class ClassNode(ASTNode):
                 raise Exception("ERROR: Class '{}' declares 2 constructors with the same parameter types".format(self.name))
             unique.append(key)
         
-        # 6. The hierarchy must be acyclic
-        # 9. A class or interface must not contain (declare or inherit) two methods with the same signature but different return types
-        # 11. A nonstatic method must not replace a static method
-        # 13. A protected method must not replace a public method
-        # 14. A method must not replace a final method
-        contains = self.getContains([])
+        # centralized point for overlapping class & interface logic
+        contains = super().checkHierarchy()
+
         # 10. A class that contains (declares or inherits) any abstract methods must be abstract.
         for con in contains:
             if 'abstract' in con.mods and 'abstract' not in self.mods:
@@ -121,20 +161,16 @@ class ClassNode(ASTNode):
 
     # hierarchy: string[]
     def getContains(self, hierarchy):
-        # TODO: move this to a more centralized spot for both ClassNode and InterNode?
-        # TODO: need to check all of the implemented interfaces as well ***
+        # centralized logic
+        contains = super().getContains(hierarchy)
         
-        # check if not acyclic
-        if self.name in hierarchy:
-            raise Exception("ERROR: The hierarchy is not acyclic '{}', saw '{}'".format(hierarchy, self.name))
-        hierarchy.append(self.name)
-        # get contains
-        contains = self.methods
+        # get contains from extends class
         if self.superClass:
+            addToContains = []
             superContains = self.superClass.getContains(hierarchy)
             for con in superContains:
                 conOverwritten = False
-                for method in self.methods:
+                for method in contains:
                     if (method == con):
                         # cannot have same signiture but different return types
                         if (method.methodType != con.methodType):
@@ -151,7 +187,8 @@ class ClassNode(ASTNode):
                         conOverwritten = True
                         break
                 if not conOverwritten:
-                    contains.append(con)
+                    addToContains.append(con)
+            contains += addToContains
         return contains
 
     def getConstructor(self, argTypes):
@@ -161,7 +198,7 @@ class ClassNode(ASTNode):
 
 #####################################################################
 # interface
-class InterNode(ASTNode):
+class InterNode(ClassInterNode):
     # always list all fields in the init method to show the class structure
     def __init__(self, parseTree):
         self.parseTree = parseTree
@@ -214,41 +251,10 @@ class InterNode(ASTNode):
                     raise Exception("ERROR: Interface '{}' extends duplicate interfaces '{}'".format(self.name, inter.name))
                 unique.append(inter.name)
 
-        # 7. A class or interface must not declare two methods with the same signature (name and parameter types).
-        unique = []
-        for method in self.methods:
-            key = (method.name, method.paramTypes)
-            if key in unique:
-                raise Exception("ERROR: Interface '{}' declares 2 methods with the same signature '{}'".format(self.name, key[0]))
-            unique.append(key)
-
-        # 6. The hierarchy must be acyclic
-        # 9. A class or interface must not contain (declare or inherit) two methods with the same signature but different return types
-        # 13. A protected method must not replace a public method
-        contains = self.getContains([])
+        # centralized point for overlapping class & interface logic
+        contains = super().checkHierarchy()
 
     # hierarchy: string[]
     def getContains(self, hierarchy):
-        # check if not acyclic
-        if self.name in hierarchy:
-            raise Exception("ERROR: The hierarchy is not acyclic '{}'".format(hierarchy))
-        hierarchy.append(self.name)
-        # get contains
-        contains = self.methods
-        for inter in self.superInter:
-            superContains = inter.getContains(hierarchy)
-            for con in superContains:
-                conOverwritten = False
-                for method in self.methods:
-                    if (method == con):
-                        # cannot have same signiture but different return types
-                        if (method.methodType != con.methodType):
-                            raise Exception("ERROR: Interface '{}' contains 2 methods '{}' with the same signature but different return types".format(self.name, method.name))
-                        # protected must not replace public
-                        if 'protected' in method.mods and 'public' in con.mods:
-                            raise Exception("ERROR: Protected method '{}' in class '{}' replaces public method '{}' in class {}".format(method.name, self.name, con.name, inter.name))
-                        conOverwritten = True
-                        break
-                if not conOverwritten:
-                    contains.append(con)
-        return contains
+        # centralized logic
+        return super().getContains(hierarchy)
\ No newline at end of file