ClassType.zu

#
# The Zimbu compiler written in Zimbu
#
# ClassType class.
#
# A Type used for classes and interfaces.
#
# Copyright 2011 Bram Moolenaar  All Rights Reserved.
# Licensed under the Apache License, Version 2.0.  See the LICENSE file or
# obtain a copy at: http://www.apache.org/licenses/LICENSE-2.0
#

IMPORT.PROTO "zui.proto"

IMPORT "ClassRefType.zu"
IMPORT "ClassScope.zu"
IMPORT "Declaration.zu"
IMPORT "Generate.zu"
IMPORT "MethodType.zu"
IMPORT "Output.zu"
IMPORT "ReferenceType.zu"
IMPORT "SContext.zu"
IMPORT "SymUse.zu"
IMPORT "Template.zu"
IMPORT "Type.zu"
IMPORT "ZuiDeclarationExt.zu"

IMPORT "lib/ILoader.zu"


CLASS ClassType EXTENDS ReferenceType @items=public
  # Scope that contains $members and $objectMembers
  ClassScope             $scope

  # Parent class, if any.
  ClassType              $parent

  # Inheritance level, number of classes to the top.
  int                    $parentLevel

  # Interfaces the class declared to implement.
  # This can also be SomeClass.I, which is an ClassRefType iobject.
  list<Declaration>      $interfaces

  # Known child classes.
  list<ClassType>        $children

  # Classes known to implement this interface.
  list<ClassType>        $implementers

  # Class used for variable that needs to be allocated, can't be on the stack.
  Declaration            $allocDecl

  # When not NIL this class is templated and it lists the templates that were
  # found for this class.
  list<Template>         $templateList

  # When not NIL the list of names used in the template: <Tone, Ttwo>
  list<string>           $templateNames

  # When not NIL the list of types used: <int, string>
  list<Declaration>      $templateTypes

  # Unique class ID, for debugging class identity.
  int                    $classId

  # Fake $Init() declaration, only used when there is no real $Init().
  # $initDecl.defined is TRUE when it is used.
  MethodType             $initDecl

  # Object member declarations with inits.  These are also used by children.
  list<Zui.Declaration>  $memberInits

  # Object member declarations with inits.  These are NOT used by children.
  list<Zui.Declaration>  $ownMemberInits

  # Keep track of using the interfaceMemberTableTable
  Declaration.C          $imttDecl

  # A lazily created declaration for the interface of this class, used for
  # MyClass.I
  Declaration            $interfaceObjectDecl

  # A lazily created declaration for the interface of this class, used for
  # MyClass when it has children.
  Declaration            $interfaceObjectDeclAuto

  # Cached value type.  Can be an iobject for a class with children.
  ClassRefType           $valueType
  # $valueType was set when $children was not empty
  bool                   $valueTypeHadChildren

  # Cached object type.  For a class it is always an object, not iobject.
  ClassRefType           $objectType

  # Cached starred type.
  ClassRefType           $starType

  # For generating JS: whether the class has been written.
  bool                   $jsWritten

  NEW(Type.Enum type, string name) @replace
    IF type == Type.Enum.class
        || type == Type.Enum.interface
        || type == Type.Enum.piece
      PARENT.NEW(type, name)
    ELSE
      LOG.internal("Creating ClassType with type \(type.ToString())")
    }
    $classId = ++nextClassId
  }

  # Make a copy of this Type.  Every subclass must redefine it.
  FUNC $copyType() Type @replace @default
    ClassType ret = NEW($ttype, $name)
    $copyClassValues(ret)
    RETURN ret
  }

  # Copy the values of this object into |ret|.
  PROC $copyClassValues(ClassType ret) @default
    $copyReferenceValues(ret)
    ret.scope = $scope
    ret.parent = $parent
    ret.parentLevel = $parentLevel
    ret.interfaces = $interfaces
    ret.children = $children
    ret.implementers = $implementers
    ret.templateList = $templateList
    ret.templateNames = $templateNames
    ret.memberInits = $memberInits
    ret.ownMemberInits = $ownMemberInits
    IF ret.classId == 0  # should not happen
      IF $classId > 0
        ret.classId = $classId + 1000
      ELSE
        ret.classId = ++nextClassId + 1000
      }
    }
    ret.imttDecl = $imttDecl
    ret.interfaceObjectDecl = $interfaceObjectDecl
    ret.interfaceObjectDeclAuto = $interfaceObjectDeclAuto
  }

  # Return the name for the object declaration table.
  # Return NIL if this is not an object.
  FUNC $getTypeName(SContext ctx) string @replace
    IF $pName == NIL
      RETURN "unknown"  # error should be given elsewhere
    }
    RETURN $pName
  }

  # Return TRUE for types that use managed memory.  This excludes pointers to
  # callbacks, these are in static memory.  Also exclude references, e.g. an
  # "&undef" argument.
  FUNC $isManaged() bool @replace
    RETURN TRUE
  }

  # Return TRUE for types that can have an instance: Class, Enum, Bits.
  FUNC $needCopyValue() bool @replace
    RETURN TRUE
  }

  # Return the type of an object.  When this type is an interface or a class
  # with children this returns an iobject.
  FUNC $getValueType(SContext ctx) Type @replace
    bool hasChildren = $children != NIL && $children.Size() > 0
    IF $valueType == NIL || $valueTypeHadChildren != hasChildren
      # Use "object" for "Foo.C" and for "Foo" when there are no children.
      # Note that children may be added later, remember that in
      # $valueTypeHadChildren
      IF $ttype == Type.Enum.classDotC
                                || ($ttype == Type.Enum.class && !hasChildren)
        $valueType = NEW(Type.Enum.object, THIS, "instance of " .. $name)
      ELSE
        $valueType = NEW(Type.Enum.iobject, THIS, "instance of " .. $name)
      }
      IF $zuiAttr != NIL
        $valueType.zuiAttr = $zuiAttr.copy(TRUE)
        $valueType.zuiAttr.setAbstract(FALSE)
      }
      $valueType.addDependsOn(THIS)
      $valueTypeHadChildren = hasChildren
    }
    IF !hasChildren && $valueType.ttype == Type.Enum.object
      # If the type is an object it might become an iobject if children are
      # added to the class.  Must come back here if that happens.
      $scope.addScopeDependency(ctx.scope)
    }
    RETURN $valueType
  }

  # Return an object of this class.
  FUNC $getObject() ClassRefType
    IF $objectType == NIL
      IF $ttype == Type.Enum.classDotC || $ttype == Type.Enum.class
        $objectType = NEW(Type.Enum.object, THIS, "instance of " .. $name)
      ELSE
        $objectType = NEW(Type.Enum.iobject, THIS, "instance of " .. $name)
      }
      IF $zuiAttr != NIL
        $objectType.zuiAttr = $zuiAttr.copy(TRUE)
        $objectType.zuiAttr.setAbstract(FALSE)
      }
      $objectType.addDependsOn(THIS)
    }
    RETURN $objectType
  }

  # Return a class with the type "classDotC", the class itself: MyClass.C
  FUNC $getStarType(Zui.Position pos, SContext ctx) ClassRefType @replace
    IF $starType == NIL
      IF $ttype != Type.Enum.class
        ctx.error("Cannot use * after an interface name", pos)
      }
      $starType = NEW(Type.Enum.classDotC, THIS, $name .. "*")
      IF $zuiAttr != NIL
        $starType.zuiAttr = $zuiAttr.copy(TRUE)
      }
      $starType.addDependsOn(THIS)
    }
    RETURN $starType
  }

  # Return a declaration for an object of the interface of this class.
  # It is stored, so that the same declaration is returned every time.
  # Used for MyClass.I.
  FUNC $getInterfaceObjectDecl() Declaration
    IF $interfaceObjectDecl == NIL
      $interfaceObjectDecl = $makeInterfaceObjectDecl()
    }
    RETURN $interfaceObjectDecl
  }

  # Return a declaration for an object of the interface of this class.
  # It is stored, so that the same declaration is returned every time.
  # Used for MyClass where it means MyClass.I if it has children.
  FUNC $getInterfaceObjectDeclAuto() Declaration
    IF $interfaceObjectDeclAuto == NIL
      ClassRefType iobject = $makeInterfaceObjectDecl()
      iobject.isAuto = TRUE
      $interfaceObjectDeclAuto = iobject
    }
    RETURN $interfaceObjectDeclAuto
  }

  # Create an interface object for $interfaceObjectDecl or
  # $interfaceObjectDeclAuto.
  FUNC $makeInterfaceObjectDecl() ClassRefType
    # Create an iclass ClassRefType, then make an iobject ClassRefType
    # that references it.
    ClassRefType iclass = NEW(Type.Enum.iclass, THIS, "interface of " .. $name)

    ClassRefType iobject = NEW(Type.Enum.iobject, iclass,
                                                     "interface of " .. $name)
    iobject.zuiDecl = $zuiDecl.copy(FALSE)
    iobject.zuiPos = $zuiPos

    iobject.addDependsOn(THIS)
    RETURN iobject
  }

  # Return the name of the class instead of just "class".
  FUNC $typeName(bool long) string @replace
    string id = !long || $classId == 0 ? "" : "/" .. $classId
    IF $scope == NIL || $scope.name == NIL
      RETURN PARENT.typeName(long) .. id
    }
    RETURN $scope.name .. id
  }

  # For a method reference return the argument list.
  # Otherwise return NIL
  FUNC $getArgList() list<Declaration.C> @replace @default
    RETURN NIL
  }

  # For a method reference return the return type.
  # Otherwise return NIL
  FUNC $getReturnType() Type @replace @default
    RETURN NIL
  }

  PROC $addInterface(Type itf, Zui.Declaration zuiDecl, SContext ctx)
    Declaration decl
    VAR declExt = ZuiDeclarationExt.get(zuiDecl)
    IF declExt.decl != NIL
      # Re-use the declaration created previously.
      decl = declExt.decl
    ELSE
      # Create a Declaration that holds the info about where the interface was
      # used.  itf.decl can be NIL for an iobject.
      IF itf.name == NIL  # TODO: cannot happen?
        decl = Declaration.NEW("none")
      ELSE
        decl = Declaration.NEW(itf.name)
      }
      decl.type = itf
      decl.zuiDecl = zuiDecl
      declExt.decl = decl
    }

    IF $interfaces == NIL
      $interfaces = NEW()
    ELSE
      # Only add it when it isn't there yet
      FOR s IN $interfaces
        IF s.type IS decl.type
          ctx.error("Duplicate interface: " .. decl.name, zuiDecl)
          RETURN
        }
      }
    }

    $interfaces.add(decl)
  }

  FUNC $findMember(string name, SymUse symUse) Declaration @replace
    IF $scope == NIL
      RETURN NIL
    }
    Declaration decl = Declaration.find($scope.declDict, name)
    decl = $verifyAccess(decl, symUse)
    IF decl == NIL && $parent != NIL
      RETURN $parent.findMember(name, symUse)
    }
    RETURN decl
  }

  # Remove member |decl|.
  PROC $removeMember(Declaration decl)
    $scope.removeMember(decl)
  }

  # Add object member |decl|.
  PROC $addObjectMember(Declaration decl)
    $scope.addObjectMember(decl)
  }

  # Return TRUE if there are any members to be initialized, either in this
  # class or in parents.
  FUNC $hasMemberInits() bool
    IF $memberInits != NIL || $ownMemberInits != NIL
      RETURN TRUE
    }
    ClassType parent = $parent
    WHILE parent != NIL
      IF parent.memberInits != NIL
        RETURN TRUE
      }
      parent = parent.parent
    }
    RETURN FALSE
  }

  # Add initialization of an object member, to be taken over by children.
  PROC $addMemberInit(Zui.Declaration zuiDecl)
    IF $memberInits == NIL
      $memberInits = NEW()
    }
    $addSomeMemberInit(zuiDecl, $memberInits)
  }

  # Add initialization of an object member, not used by children.
  PROC $addOwnMemberInit(Zui.Declaration zuiDecl)
    IF $ownMemberInits == NIL
      $ownMemberInits = NEW()
    }
    $addSomeMemberInit(zuiDecl, $ownMemberInits)
  }

  # Add initialization of an object member to |inits|.
  PROC $addSomeMemberInit(Zui.Declaration zuiDecl, list<Zui.Declaration> inits)
    FOR decl IN inits
      IF decl IS zuiDecl
        RETURN  # already added
      }
    }
    inits.add(zuiDecl)
  }

  # Remove object member |decl|.
  PROC $removeObjectMember(Declaration decl)
    $scope.removeObjectMember(decl)
  }

  # Search for |name| in the object member dict, checking for usage with 
  # |symUse|.  Only search parents when |options.searchParent| is TRUE.
  # Returns the first one that is visible.  NIL if none are visible.
  FUNC $findObjectMember(string name,
                         SymUse symUse,
                         MethodType.FindFuncOptions options,
                         bool inParent
                        ) Declaration @replace
    # Get all declarations for "name" and find the first one that is visible.
    list<Declaration> declList = Declaration.findAll($getObjectDeclDict(), name)
    Declaration decl
    FOR d IN declList
      # A declaration with @local cannot be used from a child class.
      IF !inParent || !d.hasLocalAttr() || options.ignoreLocal
        decl = $verifyAccess(d, symUse)
        IF decl != NIL
          BREAK
        }
      }
    }
    IF decl == NIL && options.searchParent && $parent != NIL
      RETURN $parent.findObjectMember(name, symUse, options, TRUE)
    }
    RETURN decl
  }

  # Find the first method with name |method| that matches the arguments
  # |argList|.  Skip |skip.method|.
  # The caller should probably check if there is another function
  # that matches.
  PROC $findMatchingMethods(string method,
                            bool objectMethod,
                            list<Declaration.C> argList,
                            MethodType.Skip skip,
                            MethodType.FindFuncOptions options,
                            int &undef,
                            multiDict<int, Declaration> funcs,
                            SContext ctx
                           ) @replace
    Declaration match
    IF $scope != NIL
      multiDict<string, Declaration> declList
      IF objectMethod
        IF $scope.objectMembers != NIL
          declList = $scope.objectMembers
        }
      ELSEIF !options.skipShared
        declList = $scope.declDict
      }
      IF declList != NIL
        MethodType.findMatchingFunctionsInList(declList.get(method, NIL),
                            method, argList, skip, options, undef, funcs, ctx)
        IF funcs.Size() > 0
          match = funcs.get(funcs.keys()[0])[0]
        }
      }
    }
    IF match == NIL
        && $parent != NIL
        && options.searchParent
        && (skip == NIL || !skip.foundSkip)
              # object Methods are copied from parent, don't look in parent
        && (!objectMethod || $ttype == Type.Enum.interface)
      $parent.findMatchingMethods(method, objectMethod, argList,
                                         skip, options, undef, funcs, ctx)
    }
  }

  # Return the NEW() method that accepts a list of items or a dict with items.
  FUNC $findNewFromContainerMethod(Zui.Expression expr,
                              Type.Enum ttype, string tName,
                                             SContext ctx) MethodType @replace
    MethodType found
    IF $getObjectDeclDict() != NIL
      FOR l IN $getObjectDeclDict().values()
        FOR d IN l
          IF d.name == "NEW"
            list<Declaration.C> argList = d.type.getArgList()
            IF argList.Size() == 1 && argList[0].type.ttype == ttype
              IF found != NIL
                IF ctx.doError()
                   ctx.error("More than one NEW method that accepts a "
                                                            .. tName, expr)
                }
                RETURN NIL
              }
              found = d.type
            }
          }
        }
      }
    }
    IF found == NIL && ctx.doError()
      ctx.error("No NEW method that accepts a " .. tName, expr)
    }
    RETURN found
  }

  # Return TRUE when |child| is this class or a subclass of this class,
  # directly or indirectly.
  FUNC $hasSubclass(ClassType child) bool
    RETURN $subClassDepth(child) >= 0
  }

  # Return how deep |child| can be found as a child of this class.
  # Return -1 if not found.
  FUNC $subClassDepth(ClassType child) int
    IF child IS THIS
      RETURN 0
    }
    IF $children != NIL
      FOR m IN $children
        int n = m.subClassDepth(child)
        IF n >= 0
          RETURN n + 1
        }
      }
    }
    RETURN -1
  }

  # Return the class type.
  FUNC $getClassType(SContext ctx) ClassType @replace
    RETURN THIS
  }

  # Get the dictionary with member Declarations.
  FUNC $getDeclDict() multiDict<string, Declaration> @replace
    IF $scope != NIL
      RETURN $scope.declDict
    }
    RETURN NIL
  }

  FUNC $hasAnyMembers() bool @replace
    RETURN TRUE
  }

  # Get the list of object member Declarations.
  FUNC $getObjectDeclDict() multiDict<string, Declaration> @replace
    IF $scope != NIL
      RETURN $scope.getObjectDeclDict()
    }
    RETURN NIL
  }

  PROC $addChild(Type child, SContext ctx)
    IF $children == NIL
      $children = NEW()
      # If a child is added code that uses this interface needs another pass.
      # Objects change from object to iobject type.
      $scope.setNeedPassInDependencies(ctx)
    ELSE
      # Only add it when it isn't there yet, implemented interfaces are added
      # again each pass.
      FOR s IN $children
        IF s IS child
          RETURN
        }
      }
    }

    $children.add(child)
  }

  # Return TRUE when this class has any children.
  FUNC $hasChildren() bool
    RETURN $children != NIL && $children.Size() > 0
  }

  # Return the index of |child| in the list of children, used as the index
  # in the argument type lookup function.
  # If |last| is TRUE then return the index plus children count plus one.
  FUNC $childIndex(Type child, bool last) int
    IF child == NIL
      RETURN 0
    }
    IF child IS THIS && !last
      # Index of the parent itself is zero.
      RETURN 0
    }
    int i = $findChild(child, last)
    IF i >= 0
      # Index of a child is list index, plus one for non-abstract class.
      RETURN i + ($isAbstract() ? 0 : 1)
    }
    IF child IS THIS
      # Return children count, plus one for the parent itself.
      RETURN -i
    }
    RETURN -1
  }

  # Find |child| in children, return its index.
  # This works recursively.
  # If |last| is TRUE then return the index plus children count plus one.
  # Return -(number of children) - 1 when not found.
  FUNC $findChild(Type child, bool last) int
    int idx
    IF $children != NIL
      FOR c IN $children
        IF c IS child && !last
          RETURN idx
        }
        IF !c.isAbstract()
          idx++
        }
        int ci = c.findChild(child, last)
        IF ci >= 0
          RETURN idx + ci
        }
        idx += -(ci + 1)
        IF c IS child && last
          RETURN idx
        }
      }
    }
    RETURN -(idx + 1)
  }

  PROC $imttUsed(SContext ctx)
    IF $imttDecl == NIL
      $imttDecl = NEW($name .. "__imtt")
    }
    ctx.addUsedItem($imttDecl)

    # All _imt tables inside it are used for used classes.
    $imtUsed(THIS, ctx)
  }

  PROC $imtUsed(Declaration itf, SContext ctx)
    $usingInterface(itf, ctx)
    IF $children != NIL
      FOR child IN $children
        child.imtUsed(itf, ctx)
      }
    }
  }

  # Return TRUE when this class or any child has a Finish() method.
  FUNC $hasFinishMethod(SContext ctx) bool
    IF Generate.getFinishMethod($scope, ctx) != NIL
      RETURN TRUE
    ELSEIF $children != NIL
      FOR child IN $children
        IF child.hasFinishMethod(ctx)
          RETURN TRUE
        }
      }
    }
    RETURN FALSE
  }

  # Return the types as they are used in a typespec.
  # foo<type0, type1>
  FUNC $getTypespecType(int idx) Type @replace
    IF $templateTypes != NIL && $templateTypes.Size() > idx
      RETURN $templateTypes[idx].type
    }
    RETURN NIL
  }

  # Return TRUE when this is a class used to store an allocated variable, used
  # in a USE &argument.
  FUNC $isAllocType(SContext ctx) bool @replace
    RETURN $allocDecl != NIL
  }

  # Return TRUE if this class is I.Iterable or a templated class of it.
  FUNC $isIterable() bool
    Declaration iterableDecl = ILoader.getIterableDecl()
    RETURN THIS IS iterableDecl.type || ($scope.template != NIL
                        && $scope.template.templateClass IS iterableDecl.type)
  }

  # Return TRUE if this class implements I.Iterable or one of the parents
  # does.
  FUNC $implementsIterable(SContext ctx) bool
    IF $isIterable()
      RETURN TRUE
    }
    FOR itf IN $interfaces ?: []
      IF itf.type.getClassType(ctx).isIterable()
        RETURN TRUE
      }
    }
    IF $parent != NIL
      RETURN $parent.implementsIterable(ctx)
    }
    RETURN FALSE
  }

  # Return TRUE if this class is I.Iterator or a templated class of it.
  FUNC $isIterator() bool
    Declaration iteratorDecl = ILoader.getIteratorDecl()
    RETURN THIS IS iteratorDecl.type || ($scope.template != NIL
                        && $scope.template.templateClass IS iteratorDecl.type)
  }

  # Return TRUE if this class implements I.Iterator or one of the parents
  # does.
  FUNC $implementsIterator(SContext ctx) bool
    IF $isIterator()
      RETURN TRUE
    }
    FOR itf IN $interfaces ?: []
      IF itf.type.getClassType(ctx).isIterator()
        RETURN TRUE
      }
    }
    IF $parent != NIL
      RETURN $parent.implementsIterator(ctx)
    }
    RETURN FALSE
  }

  # Return TRUE if this class is I.KeyIterator or a templated class of it.
  FUNC $isKeyIterator() bool
    Declaration iteratorDecl = ILoader.getKeyIteratorDecl()
    RETURN THIS IS iteratorDecl.type || ($scope.template != NIL
                        && $scope.template.templateClass IS iteratorDecl.type)
  }

  # Return TRUE if this class implements I.KeyIterator or one of the parents
  # does.
  FUNC $implementsKeyIterator(SContext ctx) bool
    IF $isKeyIterator()
      RETURN TRUE
    }
    FOR itf IN $interfaces ?: []
      IF itf.type.getClassType(ctx).isKeyIterator()
        RETURN TRUE
      }
    }
    IF $parent != NIL
      RETURN $parent.implementsKeyIterator(ctx)
    }
    RETURN FALSE
  }

  SHARED

    int nextClassId

  }

}