Submitting First HW

java-type-checker/java_type_checker/expressions.py

@@ -14,6 +14,7 @@ def static_type(self):
         Returns the compile-time type of this expression, i.e. the most specific type that describes
         all the possible values it could take on at runtime. Subclasses must implement this method.
         """
+
         raise NotImplementedError(type(self).__name__ + " must implement static_type()")
 
     def check_types(self):
@@ -31,6 +32,12 @@ def __init__(self, name, declared_type):
         self.name = name                    #: The name of the variable
         self.declared_type = declared_type  #: The declared type of the variable (Type)
 
+    def static_type(self):
+        return self.declared_type
+
+    def check_types(self):
+        pass
+
 
 class Literal(Expression):
     """ A literal value entered in the code, e.g. `5` in the expression `x + 5`.
@@ -39,11 +46,22 @@ def __init__(self, value, type):
         self.value = value  #: The literal value, as a string
         self.type = type    #: The type of the literal (Type)
 
+    def static_type(self):
+        return self.type
+
+    def check_types(self):
+        pass
 
 class NullLiteral(Literal):
     def __init__(self):
         super().__init__("null", Type.null)
 
+    def static_type(self):
+        return Type.null
+
+    def check_types(self):
+        pass
+
 
 class MethodCall(Expression):
     """
@@ -55,6 +73,37 @@ def __init__(self, receiver, method_name, *args):
         self.method_name = method_name  #: The name of the method to call (String)
         self.args = args                #: The method arguments (list of Expressions)
 
+    def static_type(self):
+        return self.receiver.static_type().method_named(self.method_name).return_type
+
+
+    def check_types(self):
+
+        for arg in self.args:
+            arg.check_types()
+
+
+        correctTypes = self.receiver.static_type().method_named(self.method_name).argument_types
+        argTypes = []
+        for arg in self.args:
+            argTypes += [arg.static_type()]
+
+        if len(correctTypes) != len(argTypes):
+            raise JavaTypeError(
+                "Wrong number of arguments for {0}: expected {1}, got {2}".format(
+                    "{}.{}()".format(self.receiver.static_type().name, self.method_name),
+                    len(correctTypes),
+                    len(argTypes)))
+
+        for i in range(len(correctTypes)):
+            if not argTypes[i].is_subtype_of(correctTypes[i]):
+                raise JavaTypeError(
+                    "{0} expects arguments of type {1}, but got {2}".format(
+                        "{}.{}()".format(self.receiver.static_type().name, self.method_name),
+                        names(correctTypes),
+                        names(argTypes)))
+
+
 
 class ConstructorCall(Expression):
     """
@@ -64,6 +113,38 @@ def __init__(self, instantiated_type, *args):
         self.instantiated_type = instantiated_type  #: The type to instantiate (Type)
         self.args = args                            #: Constructor arguments (list of Expressions)
 
+    def static_type(self):
+        return self.instantiated_type
+
+    def check_types(self):
+
+
+        for arg in self.args:
+            arg.check_types()
+
+        correctTypes = self.instantiated_type.constructor.argument_types
+        argTypes = []
+        for arg in self.args:
+            argTypes += [arg.static_type()]
+
+
+        if len(correctTypes) != len(argTypes):
+            raise JavaTypeError(
+                "Wrong number of arguments for {0}: expected {1}, got {2}".format(
+                    self.instantiated_type.name + " constructor",
+                    len(correctTypes),
+                    len(argTypes)))
+
+        for i in range(len(correctTypes)):
+            if not argTypes[i].is_subtype_of(correctTypes[i]):
+                raise JavaTypeError(
+                    "{0} expects arguments of type {1}, but got {2}".format(
+                        self.instantiated_type.name + " constructor",
+                        names(correctTypes),
+                        names(argTypes)))
+
+
+
 
 class JavaTypeError(Exception):
     """ Indicates a compile-time type error in an expression.

java-type-checker/java_type_checker/types.py

@@ -12,7 +12,13 @@ def __init__(self, name, direct_supertypes=[]):
     def is_subtype_of(self, other):
         """ True if this type can be used where the other type is expected.
         """
-        return True  # TODO: implement
+        if other == self:
+            return True
+        for type in self.direct_supertypes:
+            if type.is_subtype_of(other):
+                return True
+        return False
+
 
     def is_supertype_of(self, other):
         """ Convenience counterpart to is_subtype_of().

python-attr-lookup/python-attr-lookup.iml

@@ -20,5 +20,17 @@
         <SOURCES />
       </library>
     </orderEntry>
+    <orderEntry type="module-library" scope="TEST">
+      <library name="JUnit5.0">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.0.0/junit-jupiter-api-5.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.0.0/apiguardian-api-1.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.0.0/opentest4j-1.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.0.0/junit-platform-commons-1.0.0.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
   </component>
 </module>

python-attr-lookup/src/plang/PythonObject.java

@@ -51,7 +51,17 @@ public List<PythonObject> getMRO() {
      * result (i.e. it remembers the list buildMRO() returned and keeps returning it).
      */
     protected List<PythonObject> buildMRO() {
-        throw new UnsupportedOperationException("not implemented yet");
+
+        List<PythonObject> mro = new ArrayList<PythonObject>();
+
+        mro.add(this);
+
+        if (type != null){
+            List<PythonObject> moreMRO = type.buildMRO();
+            mro.addAll(moreMRO);
+        }
+        return mro;
+
     }
 
     /**
@@ -62,7 +72,17 @@ protected List<PythonObject> buildMRO() {
      * @throws PythonAttributeException When there is no attribute on this object with that name.
      */
     public final PythonObject get(String attrName) throws PythonAttributeException {
-        throw new UnsupportedOperationException("not implemented yet");
+
+
+        for (PythonObject o : getMRO()){
+            if (o.attrs.containsKey(attrName)){
+                return o.attrs.get(attrName);
+            }
+        }
+
+        throw new PythonAttributeException(this, attrName);
+
+
     }
 
     /**
@@ -73,8 +93,9 @@ public final PythonObject get(String attrName) throws PythonAttributeException {
      * @param attrName The name of the attribute to set
      * @param value Its new value
      */
+
     public final void set(String attrName, PythonObject value) {
-        throw new UnsupportedOperationException("not implemented yet");
+            attrs.put(attrName, value);
     }
 
     @Override

python-attr-lookup/src/plang/PythonType.java

@@ -41,15 +41,26 @@ public PythonObject getBase() {
 
     @Override
     protected List<PythonObject> buildMRO() {
-        throw new UnsupportedOperationException("not implemented yet");
+        List<PythonObject> mro = new ArrayList<PythonObject>();
+
+        mro.add(this);
+        PythonType tmp = this;
+        while (tmp.getBase() != null) {
+            mro.add(tmp.base);
+            tmp = (PythonType)tmp.base;
+        }
+        return mro;
+
     }
 
     /**
      * Creates and returns a new instance of this class, i.e. a PythonObject whose type is
      * this PythonType.
      */
     public PythonObject instantiate() {
-        throw new UnsupportedOperationException("not implemented yet");
+        PythonObject newInstance = new PythonObject(this);
+
+        return newInstance;
     }
 
     @Override