definitions.scala

JAVA 语言的函数式编程扩展

/* NSC -- new Scala compiler
 * Copyright 2005-2008 LAMP/EPFL
 * @author  Martin Odersky
 */
// $Id: Definitions.scala 14509 2008-04-05 15:16:36Z dragos $

package scala.tools.nsc.symtab

import scala.collection.mutable.{HashMap, HashSet}
import scala.tools.nsc.util.{Position, NoPosition}
import Flags._

trait Definitions {
  self: SymbolTable =>

  object definitions {
    def isDefinitionsInitialized = isInitialized

    // root packages and classes
    lazy val RootPackage: Symbol = NoSymbol.newValue(NoPosition, nme.ROOTPKG)
          .setFlag(FINAL | MODULE | PACKAGE | JAVA)
          .setInfo(PolyType(List(), RootClass.tpe))
    lazy val RootClass: Symbol = {
      NoSymbol.newClass(NoPosition, nme.ROOT.toTypeName)
        .setFlag(FINAL | MODULE | PACKAGE | JAVA).setInfo(rootLoader)
    }
    lazy val EmptyPackage: Symbol = RootClass.newPackage(NoPosition, nme.EMPTY_PACKAGE_NAME).setFlag(FINAL)

    lazy val EmptyPackageClass: Symbol = EmptyPackage.moduleClass

    var emptypackagescope: Scope = null //debug

    lazy val JavaLangPackage: Symbol = getModule(sn.JavaLang)
    lazy val ScalaPackage: Symbol = getModule("scala")
    lazy val ScalaPackageClass: Symbol = ScalaPackage.tpe.typeSymbol

    var AnyClass: Symbol = _
    var AnyValClass: Symbol = _
    var AnyRefClass: Symbol = _
    lazy val ObjectClass: Symbol = getClass(sn.Object)

    lazy val anyrefparam = List(AnyRefClass.typeConstructor)

    var AllRefClass: Symbol = _
    var AllClass: Symbol = _
    var SingletonClass: Symbol = _

    lazy val ClassClass: Symbol = getClass(sn.Class)
    lazy val StringClass: Symbol = getClass(sn.String)
    lazy val ThrowableClass: Symbol = getClass(sn.Throwable)
    lazy val NullPointerExceptionClass: Symbol = getClass(sn.NPException)
    lazy val NonLocalReturnExceptionClass: Symbol = getClass(sn.NLRException)
    lazy val InvocationTargetExceptionClass: Symbol =
      getClass("java.lang.reflect.InvocationTargetException") // java is hard coded because only used by structural values

    // System.ValueType
    lazy val ValueTypeClass: Symbol = getClass(sn.ValueType)
    // System.MulticastDelegate
    lazy val DelegateClass: Symbol = getClass(sn.Delegate)
    var Delegate_scalaCallers: List[Symbol] = List()
    // Symbol -> (Symbol, Type): scalaCaller -> (scalaMethodSym, DelegateType)
    // var Delegate_scalaCallerInfos: HashMap[Symbol, (Symbol, Type)] = _
    lazy val Delegate_scalaCallerTargets: HashMap[Symbol, Symbol] = new HashMap()

    // the scala value classes
    var UnitClass: Symbol = _
    var BooleanClass: Symbol = _
      def Boolean_not = getMember(BooleanClass, nme.UNARY_!)
      def Boolean_and = getMember(BooleanClass, nme.ZAND)
      def Boolean_or  = getMember(BooleanClass, nme.ZOR)
    var ByteClass: Symbol = _
    var ShortClass: Symbol = _
    var CharClass: Symbol = _
    var IntClass: Symbol = _
      def Int_Or  = definitions.getMember(definitions.IntClass, nme.OR)
      def Int_And = definitions.getMember(definitions.IntClass, nme.AND)
      def Int_==  = definitions.getMember(definitions.IntClass, nme.EQEQ)

    var LongClass: Symbol = _
    var FloatClass: Symbol = _
    var DoubleClass: Symbol = _

    // remote classes
    //lazy val RemoteRefClass = getClass("scala.runtime.RemoteRef")
    //lazy val RemoteRefModule = getModule("scala.runtime.RemoteRef")
    //lazy val RemoteObjectRefClass = getClass("scala.runtime.remoting.RemoteObjectRef")
    //var RemoteRefClasses: HashMap[Symbol, Symbol] = _

    // the scala reference classes
    lazy val ScalaObjectClass: Symbol = getClass("scala.ScalaObject")
      def ScalaObjectClass_tag = getMember(ScalaObjectClass, nme.tag)
    lazy val AnnotationClass: Symbol = getClass("scala.Annotation")
    lazy val ClassfileAnnotationClass: Symbol = getClass("scala.ClassfileAnnotation")
    lazy val StaticAnnotationClass: Symbol = getClass("scala.StaticAnnotation")
    lazy val TypeConstraintClass: Symbol = getClass("scala.TypeConstraint")
    lazy val ManifestClass: Symbol = getClass("scala.reflect.Manifest")
    lazy val ManifestModule: Symbol = getModule("scala.reflect.Manifest")

    var CodeClass: Symbol = _
    var CodeModule: Symbol = _
      def Code_lift = getMember(CodeModule, nme.lift_)
    lazy val PartialFunctionClass: Symbol = getClass("scala.PartialFunction")
    /*
    lazy val ByNameFunctionClass: Symbol = getClass("scala.ByNameFunction")
    */
    lazy val IterableClass: Symbol = getClass("scala.Iterable")
      def Iterable_next = getMember(IterableClass, nme.next)
      def Iterable_hasNext = getMember(IterableClass, nme.hasNext)
    lazy val IteratorClass: Symbol = getClass("scala.Iterator")
    lazy val SeqClass: Symbol = getClass("scala.Seq")
    lazy val RandomAccessSeqMutableClass: Symbol = getMember(getModule("scala.RandomAccessSeq"), nme.Mutable)
    def Seq_length = getMember(SeqClass, nme.length)
      
    lazy val ListClass: Symbol = getClass("scala.List")
      def List_isEmpty = getMember(ListClass, nme.isEmpty)
      def List_head = getMember(ListClass, nme.head)
      def List_tail = getMember(ListClass, nme.tail)
    lazy val ListModule: Symbol = getModule("scala.List")
      def List_apply = getMember(ListModule, nme.apply)
    lazy val ArrayClass: Symbol = getClass("scala.Array")
      def Array_apply = getMember(ArrayClass, nme.apply)
    lazy val ArrayModule: Symbol = getModule("scala.Array")
      def ArrayModule_apply = getMember(ArrayModule, nme.apply)
    lazy val SerializableClass: Symbol = getClass(sn.Serializable)
    lazy val PredefModule: Symbol = getModule("scala.Predef")
      def Predef_classOf = getMember(PredefModule, nme.classOf)
      def Predef_classOfType(classType: Type): Type =
        if (!ClassClass.unsafeTypeParams.isEmpty && !phase.erasedTypes)
          appliedType(ClassClass.tpe, List(classType))
        else ClassClass.tpe
      def Predef_identity = getMember(PredefModule, nme.identity)
      def Predef_error    = getMember(PredefModule, nme.error)
    lazy val ConsoleModule: Symbol = getModule("scala.Console")
    lazy val MatchErrorClass: Symbol = getClass("scala.MatchError")
    //var MatchErrorModule: Symbol = _
    //  def MatchError_fail = getMember(MatchErrorModule, nme.fail)
    //  def MatchError_report = getMember(MatchErrorModule, nme.report)
    lazy val IndexOutOfBoundsExceptionClass: Symbol = getClass(sn.IOOBException)
    lazy val ScalaRunTimeModule: Symbol = getModule("scala.runtime.ScalaRunTime")
      def SeqFactory = getMember(ScalaRunTimeModule, nme.Seq);
      def checkDefinedMethod = getMember(ScalaRunTimeModule, "checkDefined")
      def isArrayMethod = getMember(ScalaRunTimeModule, "isArray")
    lazy val NotNullClass: Symbol = getClass("scala.NotNull")
    var RepeatedParamClass: Symbol = _
    var ByNameParamClass: Symbol = _
    //var UnsealedClass: Symbol = _
    lazy val UncheckedClass: Symbol = getClass("scala.unchecked")

    var EqualsPatternClass: Symbol = _

    val MaxTupleArity = 22
    val TupleClass: Array[Symbol] = new Array(MaxTupleArity + 1)
      def tupleField(n: Int, j: Int) = getMember(TupleClass(n), "_" + j)
      def isTupleType(tp: Type): Boolean = tp.normalize match {
        case TypeRef(_, sym, elems) =>
          elems.length <= MaxTupleArity && sym == TupleClass(elems.length)
        case _ =>
          false
      }
      def tupleType(elems: List[Type]) =
        if (elems.length <= MaxTupleArity) {
          val sym = TupleClass(elems.length)
          typeRef(sym.typeConstructor.prefix, sym, elems)
        } else NoType;

    lazy val ProductRootClass: Symbol = getClass("scala.Product")
      def Product_productArity = getMember(ProductRootClass, nme.productArity)
      def Product_productElement = getMember(ProductRootClass, nme.productElement)
      def Product_productPrefix = getMember(ProductRootClass, nme.productPrefix)
    val MaxProductArity = 22
    /* <unapply> */
    val ProductClass: Array[Symbol] = new Array(MaxProductArity + 1)
      def productProj(z:Symbol, j: Int): Symbol = getMember(z, nme.Product_(j))
      def productProj(n: Int,   j: Int): Symbol = productProj(ProductClass(n), j)
    /** returns true if this type is exactly ProductN[T1,...,Tn], not some subclass */
      def isExactProductType(tp: Type): Boolean = tp.normalize match {
        case TypeRef(_, sym, elems) =>
          elems.length <= MaxProductArity && sym == ProductClass(elems.length)
        case _ =>
          false
      }
      def productType(elems: List[Type]) =
        if (elems.isEmpty)
          UnitClass.tpe
        else if (elems.length <= MaxProductArity) {
          val sym = ProductClass(elems.length)
          typeRef(sym.typeConstructor.prefix, sym, elems)
        } else NoType

    /** if tpe <: ProductN[T1,...,TN], returns Some(T1,...,TN) else None */
    def getProductArgs(tpe: Type): Option[List[Type]] = 
      tpe.baseClasses.find { x => definitions.isExactProductType(x.tpe) } match {
        case Some(p) => Some(tpe.baseType(p).typeArgs)
        case _       => None
      }

    lazy val OptionClass: Symbol = getClass("scala.Option")

    lazy val SomeClass : Symbol = getClass("scala.Some")
    lazy val NoneClass : Symbol = getModule("scala.None")

    def isOptionType(tp: Type) = tp.normalize match {
      case TypeRef(_, sym, List(_)) if sym == OptionClass => true
      case _ => false
    }
    def isOptionOrSomeType(tp: Type) = tp.normalize match {
      case TypeRef(_, sym, List(_)) => sym == OptionClass || sym == SomeClass
      case _ => false
    }
    def optionType(tp: Type) =
      typeRef(OptionClass.typeConstructor.prefix, OptionClass, List(tp))

    def isSomeType(tp: Type) = tp.normalize match {
      case TypeRef(_, sym, List(_)) if sym == SomeClass => true
      case _ => false
    }
    def someType(tp: Type) =
      typeRef(SomeClass.typeConstructor.prefix, SomeClass, List(tp))

    def isNoneType(tp: Type) = tp.normalize match {
      case TypeRef(_, sym, List(_)) if sym == NoneClass => true
      case _ => false
    }

    def unapplyUnwrap(tpe:Type) = (tpe match {
      case PolyType(_,MethodType(_, res)) => res
      case MethodType(_, res)             => res
      case tpe                            => tpe
    }).normalize
    
    /* </unapply> */
    val MaxFunctionArity = 22
    val FunctionClass: Array[Symbol] = new Array(MaxFunctionArity + 1)
      def functionApply(n: Int) = getMember(FunctionClass(n), nme.apply)
      def functionType(formals: List[Type], restpe: Type) =
        if (formals.length <= MaxFunctionArity) {
          val sym = FunctionClass(formals.length)
          typeRef(sym.typeConstructor.prefix, sym, formals ::: List(restpe))
        } else NoType;
      def isFunctionType(tp: Type): Boolean = tp.normalize match {
        case TypeRef(_, sym, args) =>
          (args.length > 0) && (args.length - 1 <= MaxFunctionArity) &&
          (sym == FunctionClass(args.length - 1))
        case _ =>
          false
      }

    def isCorrespondingDelegate(delegateType: Type, functionType: Type): Boolean = {
      isSubType(delegateType, DelegateClass.tpe) &&
      (delegateType.member(nme.apply).tpe match {
	case MethodType(delegateParams, delegateReturn) =>
	  isFunctionType(functionType) &&
	  (functionType.normalize match {
	    case TypeRef(_, _, args) =>
	      (delegateParams.map(pt => {
                if (pt == AnyClass.tpe) definitions.ObjectClass.tpe else pt})
	       ::: List(delegateReturn)) == args
	    case _ => false
	  })
        case _ => false
      })
    }

    def seqType(arg: Type) =
      typeRef(SeqClass.typeConstructor.prefix, SeqClass, List(arg))

    def NilModule: Symbol = getModule("scala.Nil")
    def ConsClass: Symbol = getClass("scala.$colon$colon")

    // members of class scala.Any
    var Any_==          : Symbol = _
    var Any_!=          : Symbol = _
    var Any_equals      : Symbol = _
    var Any_hashCode    : Symbol = _
    var Any_toString    : Symbol = _
    var Any_isInstanceOf: Symbol = _
    var Any_asInstanceOf: Symbol = _
    var Any_isInstanceOfErased: Symbol = _
    var Any_asInstanceOfErased: Symbol = _