system/src/sc/lang/java/BodyTypeDeclaration.java
public boolean isAssignableFromClass(Class other) {
      /*
      Class rtClass = getRuntimeClass();
      if (rtClass == null)
         return false;
      return rtClass.isAssignableFrom(other);
      */
      String otherName = TypeUtil.getTypeName(other, true);
      if (otherName.equals(getFullTypeName()))
         return true;
      // Note: weird case here where we may have not generated a compiled class for this type.  In that case, we have
      // to allow a match between a runtime class of the base type and this one even though it might be a false match.
      //if (otherName.equals(getCompiledClassName())) {
      //System.out.println("---");
         /* TODO - remove. I don't like this case... feels like it should be an exception if we need it at all.  In any case, it should have the needsOwnClass guard here which was not here previously
         if (!needsOwnClass(true))
            return true;
         */
      //}
      Class superType = other.getSuperclass();
      if (superType != null && isAssignableFromClass(superType))
         return true;
      Class[] ifaces = other.getInterfaces();
      if (ifaces != null) {
         for (Class c : ifaces)
            if (isAssignableFromClass(c))
               return true;
      }
      return false;
   }
/**
    * Under the assumption that there's no time we'll have both the Class and TypeDeclaration of the
    * same type.
    */
Under the assumption that there's no time we'll have both the Class and TypeDeclaration of the
same type.
Under the assumption that there ' s no time we ' ll have both the Class and TypeDeclaration of the same type .
public boolean isAssignableFromClass(Class other) {
      /*
      Class rtClass = getRuntimeClass();
      if (rtClass == null)
         return false;
      return rtClass.isAssignableFrom(other);
      */
      String otherName = TypeUtil.getTypeName(other, true);
      if (otherName.equals(getFullTypeName()))
         return true;
         /* TODO - remove. I don't like this case... feels like it should be an exception if we need it at all.  In any case, it should have the needsOwnClass guard here which was not here previously
         if (!needsOwnClass(true))
            return true;
         */
      Class superType = other.getSuperclass();
      if (superType != null && isAssignableFromClass(superType))
         return true;
      Class[] ifaces = other.getInterfaces();
      if (ifaces != null) {
         for (Class c : ifaces)
            if (isAssignableFromClass(c))
               return true;
      }
      return false;
   }
public boolean isAssignableFromClass ( Class other ) { /*
      Class rtClass = getRuntimeClass();
      if (rtClass == null)
         return false;
      return rtClass.isAssignableFrom(other);
      */ String otherName = TypeUtil . getTypeName ( other , true ) ; if ( otherName . equals ( getFullTypeName ( ) ) ) return true ; /* TODO - remove. I don't like this case... feels like it should be an exception if we need it at all.  In any case, it should have the needsOwnClass guard here which was not here previously
         if (!needsOwnClass(true))
            return true;
         */ Class superType = other . getSuperclass ( ) ; if ( superType != null && isAssignableFromClass ( superType ) ) return true ; Class [ ] ifaces = other . getInterfaces ( ) ; if ( ifaces != null ) { for ( Class c : ifaces ) if ( isAssignableFromClass ( c ) ) return true ; } return false ; }
Under the assumption that there's no time we'll have both the Class and TypeDeclaration of the
 same type.
Under the assumption that there ' s no time we ' ll have both the Class and TypeDeclaration of the same type .
// Note: weird case here where we may have not generated a compiled class for this type.  In that case, we have // to allow a match between a runtime class of the base type and this one even though it might be a false match. //if (otherName.equals(getCompiledClassName())) { //System.out.println("---"); //}