New definitions and flags

3 files changed, 61 insertions, 34 deletions

diff --git a/src/dotty/tools/dotc/core/Contexts.scala b/src/dotty/tools/dotc/core/Contexts.scala
index 451d8edd3..b07319f06 100644
--- a/src/dotty/tools/dotc/core/Contexts.scala
+++ b/src/dotty/tools/dotc/core/Contexts.scala
@@ -43,7 +43,7 @@ object Contexts {
                             with Cloneable {
     implicit val ctx: Context = this
 
-    def base: ContextBase
+    val base: ContextBase
 
     private[this] var _underlying: Context = _
     protected def underlying_=(underlying: Context) = _underlying = underlying
@@ -89,11 +89,13 @@ object Contexts {
     def enclClass: Context = ???
     def erasedTypes: Boolean = ???
     def debug: Boolean = ???
-    def error(msg: String) = ???
-    def warning(msg: String) = ???
-    def log(msg: String) = ???
+    def error(msg: String): Unit = ???
+    def warning(msg: String): Unit = ???
+    def log(msg: String): Unit = ???
+    def debuglog(msg: String): Unit = ???
     def inform(msg: String) = ???
     def informTime(msg: String, start: Long): Unit = ???
+    def beforeTyper[T](op: => T): T = ???
 
     private var _condensed: CondensedContext = null
     def condensed: CondensedContext = {
@@ -137,11 +139,13 @@ object Contexts {
   }
 
   object NoContext extends Context {
-    def base = unsupported("base")
+    lazy val base = unsupported("base")
   }
 
-  class ContextBase extends ContextState with Transformers.TransformerBase
-                       with Printers.PrinterBase {
+  class ContextBase extends ContextState
+                       with Transformers.TransformerBase
+                       with Printers.PrinterBase
+                       with Denotations.DenotationsBase {
 
     val settings = new ScalaSettings
 
diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala
index 3e5e8b8af..587f244e0 100644
--- a/src/dotty/tools/dotc/core/Definitions.scala
+++ b/src/dotty/tools/dotc/core/Definitions.scala
@@ -3,11 +3,12 @@
  * @author  Martin Odersky
  */
 
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package core
 
-import Types._, Contexts._, Symbols._, SymDenotations._, StdNames._, Names._
-import Flags._, Scopes._, Decorators._, NameOps._
+import Types._, Contexts._, Symbols._, Denotations._, SymDenotations._, StdNames._, Names._
+import Flags._, Scopes._, Decorators._, NameOps._, Positions._
 import scala.annotation.{ switch, meta }
 import scala.collection.{ mutable, immutable }
 import PartialFunction._
@@ -20,9 +21,8 @@ object Definitions {
 
 class Definitions(implicit ctx: Context) {
   import Definitions._
-  def requiredPackage(str: String): TermSymbol = ???
-  def requiredClass(str: String): ClassSymbol = ???
-  def requiredModule(str: String): TermSymbol = ???
+
+  import ctx.{requiredClass, requiredModule, requiredPackage}
 
   private def newSyntheticTypeParam(cls: ClassSymbol, scope: Scope, suffix: String = "T0") = {
     val tname = suffix.toTypeName.expandedName(cls)
@@ -41,7 +41,7 @@ class Definitions(implicit ctx: Context) {
       val parentRefs: List[TypeRef] = ctx.normalizeToRefs(parents, cls, paramDecls)
       CompleteClassDenotation(cls, ScalaPackageClass, name, flags, parentRefs, decls = paramDecls)(ctx)
     }
-    new ClassSymbol(classDenot)
+    new ClassSymbol(NoOffset, classDenot)
   }
 
   private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[ClassSymbol] = {
@@ -55,6 +55,9 @@ class Definitions(implicit ctx: Context) {
   lazy val RootPackage: TermSymbol = ctx.newSymbol(
     NoSymbol, nme.ROOTPKG, PackageCreationFlags, TypeRef(NoPrefix, RootClass))
 
+  lazy val EmptyPackageClass = ctx.newPackageSymbols(RootClass, nme.EMPTY_PACKAGE)._2
+  lazy val EmptyPackageVal = EmptyPackageClass.sourceModule
+
   lazy val ScalaPackageVal = requiredPackage("scala")
   lazy val ScalaPackageClass = ScalaPackageVal.moduleClass.asClass
   lazy val JavaPackageVal = requiredPackage("java")
@@ -70,9 +73,9 @@ class Definitions(implicit ctx: Context) {
   lazy val NotNullClass = requiredClass("scala.NotNull")
 
   lazy val NothingClass: ClassSymbol = ctx.newClassSymbol(
-    ScalaPackageClass, tpnme.Nothing, UninstantiatableFlags, List(AnyType)).entered
+    ScalaPackageClass, tpnme.Nothing, UninstantiatableFlags, List(AnyClass.typeConstructor)).entered
   lazy val NullClass: ClassSymbol = ctx.newClassSymbol(
-    ScalaPackageClass, tpnme.Null, UninstantiatableFlags, List(AnyRefType)).entered
+    ScalaPackageClass, tpnme.Null, UninstantiatableFlags, List(AnyRefAlias.typeConstructor)).entered
 
   lazy val PredefModule = requiredModule("scala.Predef")
 
@@ -118,20 +121,40 @@ class Definitions(implicit ctx: Context) {
   lazy val BoxedNumberClass             = requiredClass("java.lang.Number")
   lazy val JavaSerializableClass        = requiredClass("java.lang.Serializable")
   lazy val ComparableClass              = requiredClass("java.lang.Comparable")
-  lazy val AnnotationClass              = requiredClass("scala.annotation.Annotation")
 
-  lazy val AnyType = AnyClass.typeConstructor
-  lazy val AnyValType = AnyValClass.typeConstructor
-  lazy val ObjectType = ObjectClass.typeConstructor
-  lazy val AnyRefType = AnyRefAlias.typeConstructor
-  lazy val NotNullType = NotNullClass.typeConstructor
-  lazy val NothingType = NothingClass.typeConstructor
-  lazy val NullType = NullClass.typeConstructor
-  lazy val SeqType = SeqClass.typeConstructor
-  lazy val ArrayType = ArrayClass.typeConstructor
+  // Annotation base classes
+  lazy val AnnotationClass              = requiredClass("scala.annotation.Annotation")
+  lazy val ClassfileAnnotationClass     = requiredClass("scala.annotation.ClassfileAnnotation")
+  lazy val StaticAnnotationClass        = requiredClass("scala.annotation.StaticAnnotation")
+
+  lazy val AnyType: Type = AnyClass.typeConstructor
+  lazy val AnyValType: Type = AnyValClass.typeConstructor
+  lazy val ObjectType: Type = ObjectClass.typeConstructor
+  lazy val AnyRefType: Type = AnyRefAlias.typeConstructor
+  lazy val NotNullType: Type = NotNullClass.typeConstructor
+  lazy val NothingType: Type = NothingClass.typeConstructor
+  lazy val NullType: Type = NullClass.typeConstructor
+  lazy val SeqType: Type = SeqClass.typeConstructor
+  lazy val ArrayType: Type = ArrayClass.typeConstructor
+
+  lazy val UnitType: Type = UnitClass.typeConstructor
+  lazy val BooleanType: Type = BooleanClass.typeConstructor
+  lazy val ByteType: Type = ByteClass.typeConstructor
+  lazy val ShortType: Type = ShortClass.typeConstructor
+  lazy val CharType: Type = CharClass.typeConstructor
+  lazy val IntType: Type = IntClass.typeConstructor
+  lazy val LongType: Type = LongClass.typeConstructor
+  lazy val FloatType: Type = FloatClass.typeConstructor
+  lazy val DoubleType: Type = DoubleClass.typeConstructor
+  lazy val JavaRepeatedParamType = JavaRepeatedParamClass.typeConstructor
 
   lazy val AliasAnnot = requiredClass("dotty.annotation.internal.Alias")
   lazy val ChildAnnot = requiredClass("dotty.annotation.internal.Alias")
+  lazy val ScalaSignatureAnnot = requiredClass("scala.reflect.ScalaSignature")
+  lazy val ScalaLongSignatureAnnot = requiredClass("scala.reflect.ScalaLongSignature")
+  lazy val DeprecatedAnnot = requiredClass("scala.deprecated")
+  lazy val AnnotationDefaultAnnot = requiredClass("dotty.runtime.AnnotationDefault")
+  lazy val ThrowsAnnot = requiredClass("scala.throws")
 
   def ClassType(arg: Type)(implicit ctx: Context) = {
     val ctype = ClassClass.typeConstructor
@@ -722,8 +745,6 @@ class Definitions(implicit ctx: Context) {
     lazy val StringContextClass                  = requiredClass[scala.StringContext]
          def StringContext_f                     = getMemberMethod(StringContextClass, nme.f)
 
-    lazy val ScalaSignatureAnnotation = requiredClass[scala.reflect.ScalaSignature]
-    lazy val ScalaLongSignatureAnnotation = requiredClass[scala.reflect.ScalaLongSignature]
 
     // Option classes
     lazy val OptionClass: ClassSymbol = requiredClass[Option[_]]
@@ -1113,10 +1134,6 @@ class Definitions(implicit ctx: Context) {
       def BoxedUnit_UNIT            = getMemberValue(BoxedUnitModule, nme.UNIT)
       def BoxedUnit_TYPE            = getMemberValue(BoxedUnitModule, nme.TYPE_)
 
-    // Annotation base classes
-    lazy val AnnotationClass            = requiredClass[scala.annotation.Annotation]
-    lazy val ClassfileAnnotationClass   = requiredClass[scala.annotation.ClassfileAnnotation]
-    lazy val StaticAnnotationClass      = requiredClass[scala.annotation.StaticAnnotation]
 
     // Annotations
     lazy val BridgeClass                = requiredClass[scala.annotation.bridge]
@@ -1134,7 +1151,6 @@ class Definitions(implicit ctx: Context) {
     lazy val BeanPropertyAttr           = requiredClass[scala.beans.BeanProperty]
     lazy val BooleanBeanPropertyAttr    = requiredClass[scala.beans.BooleanBeanProperty]
     lazy val CloneableAttr              = requiredClass[scala.annotation.cloneable]
-    lazy val DeprecatedAttr             = requiredClass[scala.deprecated]
     lazy val DeprecatedNameAttr         = requiredClass[scala.deprecatedName]
     lazy val DeprecatedInheritanceAttr  = requiredClass[scala.deprecatedInheritance]
     lazy val DeprecatedOverridingAttr   = requiredClass[scala.deprecatedOverriding]
@@ -1453,4 +1469,4 @@ class Definitions(implicit ctx: Context) {
     }
   }
 }
-*/
\ No newline at end of file
+*/
diff --git a/src/dotty/tools/dotc/core/Flags.scala b/src/dotty/tools/dotc/core/Flags.scala
index 5713d0629..ac4f51167 100644
--- a/src/dotty/tools/dotc/core/Flags.scala
+++ b/src/dotty/tools/dotc/core/Flags.scala
@@ -338,6 +338,10 @@ object Flags {
   /** Flags representing access rights */
   final val AccessFlags = Private | Protected | Local
 
+  final val AbstractSealed = Abstract | Sealed
+
+  final val SyntheticArtifact = Synthetic | Artifact
+
   final val RetainedModuleFlags: FlagSet = ???
 
   final val UninstantiatableFlags = Abstract | Final
@@ -389,4 +393,7 @@ object Flags {
 
   /** Java symbol which is `protected` and `static` */
   final val StaticProtected = allOf(JavaDefined, Protected, Static)
+
+  implicit def conjToFlagSet(conj: FlagConjunction): FlagSet =
+    FlagSet(conj.bits)
 }
\ No newline at end of file