From 522414cd992c90c8986f4e06fdd75942a9d87e84 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Fri, 21 Sep 2012 16:42:07 -0400 Subject: [PATCH] AbsTypeTag -> WeakTypeTag and converted more settings --- main/Defaults.scala | 72 ++++++++++++++------------------ main/settings/SettingMacro.scala | 6 +-- main/settings/TaskMacro.scala | 28 ++++++------- project/Sbt.scala | 4 +- util/appmacro/ContextUtil.scala | 2 +- util/appmacro/Instance.scala | 6 +-- 6 files changed, 56 insertions(+), 62 deletions(-) diff --git a/main/Defaults.scala b/main/Defaults.scala index 6dd6f276e..5a6789713 100755 --- a/main/Defaults.scala +++ b/main/Defaults.scala @@ -59,7 +59,7 @@ object Defaults extends BuildCommon def buildCore: Seq[Setting[_]] = thisBuildCore ++ globalCore def thisBuildCore: Seq[Setting[_]] = inScope(GlobalScope.copy(project = Select(ThisBuild)))(Seq( - managedDirectory <<= baseDirectory(_ / "lib_managed") + managedDirectory := baseDirectory.value / "lib_managed" )) def globalCore: Seq[Setting[_]] = inScope(GlobalScope)(defaultTestTasks(test) ++ defaultTestTasks(testOnly) ++ defaultTestTasks(testQuick) ++ Seq( compilerCache := state.value get Keys.stateCompilerCache getOrElse compiler.CompilerCache.fresh, @@ -179,7 +179,7 @@ object Defaults extends BuildCommon // remove when defaultExcludes are removed excludeFilter in unmanagedResources <<= (defaultExcludes in unmanagedResources) or (excludeFilter in unmanagedResources), unmanagedResources <<= collectFiles(unmanagedResourceDirectories, includeFilter in unmanagedResources, excludeFilter in unmanagedResources), - watchSources in ConfigGlobal <++= unmanagedResources, + watchSources in ConfigGlobal ++= unmanagedResources.value, resourceGenerators :== Nil, resourceGenerators <+= (definedSbtPlugins, resourceManaged) map writePluginsDescriptor, managedResources <<= generate(resourceGenerators), @@ -323,10 +323,9 @@ object Defaults extends BuildCommon testFilter in testOnly :== (selectedFilter _), testFilter in testQuick <<= testQuickFilter, executeTests <<= (streams in test, loadedTestFrameworks, testLoader, testGrouping in test, testExecution in test, fullClasspath in test, javaHome in test) flatMap allTestGroupsTask, - test <<= (executeTests, streams, resolvedScoped, state) map { - (results, s, scoped, st) => - implicit val display = Project.showContextKey(st) - Tests.showResults(s.log, results, noTestsMessage(scoped)) + test := { + implicit val display = Project.showContextKey(state.value) + Tests.showResults(streams.value.log, executeTests.value, noTestsMessage(resolvedScoped.value)) }, testOnly <<= inputTests(testOnly), testQuick <<= inputTests(testQuick) @@ -338,7 +337,9 @@ object Defaults extends BuildCommon lazy val ConfigGlobal: Scope = ThisScope.copy(config = Global) def testTaskOptions(key: Scoped): Seq[Setting[_]] = inTask(key)( Seq( testListeners <<= (streams, resolvedScoped, streamsManager, logBuffered, cacheDirectory in test, testListeners in TaskGlobal) map { (s, sco, sm, buff, dir, ls) => - TestLogger(s.log, testLogger(sm, test in sco.scope), buff) +: new TestStatusReporter(succeededFile(dir)) +: ls + TestLogger(streams.value.log, testLogger(streamsManager.value, test in resolvedScoped.value.scope), logBuffered.value) +: + new TestStatusReporter(succeededFile( cacheDirectory.in(test).value )) +: + testListeners.in(TaskGlobal).value }, testOptions := Tests.Listeners(testListeners.value) +: (testOptions in TaskGlobal).value, testExecution <<= testExecutionTask(key), @@ -509,7 +510,7 @@ object Defaults extends BuildCommon key in TaskGlobal <<= packageTask, packageConfiguration <<= packageConfigurationTask, mappings <<= mappingsTask, - packagedArtifact <<= (artifact, key) map Util.pairID, + packagedArtifact := (artifact.value, key.value), artifact <<= artifactSetting, perTaskCache(key), artifactPath <<= artifactPathSetting(artifact) @@ -568,7 +569,7 @@ object Defaults extends BuildCommon def docSetting(key: TaskKey[File]) = docTaskSettings(key) def docTaskSettings(key: TaskKey[File] = doc): Seq[Setting[_]] = inTask(key)(compileInputsSettings ++ Seq( perTaskCache(key), - target <<= docDirectory, // deprecate docDirectory in favor of 'target in doc'; remove when docDirectory is removed + target := docDirectory.value, // deprecate docDirectory in favor of 'target in doc'; remove when docDirectory is removed scalacOptions <<= scaladocOptions or scalacOptions, // deprecate scaladocOptions in favor of 'scalacOptions in doc'; remove when scaladocOptions is removed key in TaskGlobal <<= (cacheDirectory, compileInputs, target, configuration, streams) map { (cache, in, out, config, s) => val srcs = in.config.sources @@ -792,8 +793,8 @@ object Classpaths publishArtifact in GlobalScope in Test:== false, artifacts <<= artifactDefs(defaultArtifactTasks), packagedArtifacts <<= packaged(defaultArtifactTasks), - makePom <<= (ivyModule, makePomConfiguration, streams) map { (module, config, s) => IvyActions.makePom(module, config, s.log); config.file }, - packagedArtifact in makePom <<= (artifact in makePom, makePom) map Util.pairID, + makePom := { val config = makePomConfiguration.value; IvyActions.makePom(ivyModule.value, config, streams.value.log); config.file }, + packagedArtifact in makePom := (artifact in makePom value, makePom value), deliver <<= deliverTask(deliverConfiguration), deliverLocal <<= deliverTask(deliverLocalConfiguration), publish <<= publishTask(publishConfiguration, deliver), @@ -801,9 +802,9 @@ object Classpaths ) val baseSettings: Seq[Setting[_]] = sbtClassifiersTasks ++ Seq( conflictWarning in GlobalScope :== ConflictWarning.default("global"), - conflictWarning <<= (thisProjectRef, conflictWarning) { (ref, cw) => cw.copy(label = Reference.display(ref)) }, - unmanagedBase <<= baseDirectory / "lib", - normalizedName <<= name(StringUtilities.normalize), + conflictWarning := conflictWarning.value.copy(label = Reference.display(thisProjectRef.value)), + unmanagedBase := baseDirectory.value / "lib", + normalizedName := StringUtilities.normalize(name.value), isSnapshot <<= isSnapshot or version(_ endsWith "-SNAPSHOT"), description <<= description or name, homepage in GlobalScope :== None, @@ -832,13 +833,13 @@ object Classpaths moduleName <<= normalizedName, defaultConfiguration in GlobalScope :== Some(Configurations.Compile), defaultConfigurationMapping in GlobalScope <<= defaultConfiguration{ case Some(d) => "*->" + d.name; case None => "*->*" }, - ivyPaths <<= (baseDirectory, appConfiguration) { (base, app) => new IvyPaths(base, bootIvyHome(app)) }, - otherResolvers <<= publishTo(_.toList), + ivyPaths := new IvyPaths(baseDirectory.value, bootIvyHome(appConfiguration.value)), + otherResolvers := publishTo.value.toList, projectResolver <<= projectResolverTask, projectDependencies <<= projectDependenciesTask, dependencyOverrides in GlobalScope :== Set.empty, libraryDependencies in GlobalScope :== Nil, - libraryDependencies <++= (autoScalaLibrary, sbtPlugin, scalaOrganization, scalaVersion) apply autoLibraryDependency, + libraryDependencies ++= autoLibraryDependency(autoScalaLibrary.value, sbtPlugin.value, scalaOrganization.value, scalaVersion.value), allDependencies := { val base = projectDependencies.value ++ libraryDependencies.value val pluginAdjust = if(sbtPlugin.value) sbtDependency.value.copy(configurations = Some(Provided.name)) +: base else base @@ -856,36 +857,29 @@ object Classpaths moduleConfigurations in GlobalScope :== Nil, publishTo in GlobalScope :== None, artifactPath in makePom <<= artifactPathSetting(artifact in makePom), - publishArtifact in makePom <<= (publishMavenStyle, publishArtifact).apply(_ && _) , - artifact in makePom <<= moduleName(Artifact.pom), - projectID <<= (organization,moduleName,version,artifacts,crossVersion in projectID){ (org,module,version,as,cross) => - ModuleID(org, module, version).cross(cross).artifacts(as : _*) - }, + publishArtifact in makePom := publishMavenStyle.value && publishArtifact.value, + artifact in makePom := Artifact.pom(moduleName.value), + projectID := ModuleID(organization.value, moduleName.value, version.value).cross(crossVersion in projectID value).artifacts(artifacts.value : _*), projectID <<= pluginProjectID, resolvers in GlobalScope :== Nil, projectDescriptors <<= depMap, retrievePattern in GlobalScope :== Resolver.defaultRetrievePattern, - updateConfiguration <<= (retrieveConfiguration, ivyLoggingLevel)((conf,level) => new UpdateConfiguration(conf, false, level) ), - retrieveConfiguration <<= (managedDirectory, retrievePattern, retrieveManaged) { (libm, pattern, enabled) => if(enabled) Some(new RetrieveConfiguration(libm, pattern)) else None }, + updateConfiguration := new UpdateConfiguration(retrieveConfiguration.value, false, ivyLoggingLevel.value), + retrieveConfiguration := { if(retrieveManaged.value) Some(new RetrieveConfiguration(managedDirectory.value, retrievePattern.value)) else None }, ivyConfiguration <<= mkIvyConfiguration, - ivyConfigurations <<= (autoCompilerPlugins, internalConfigurationMap, thisProject) { (auto, internalMap, project) => - (project.configurations ++ project.configurations.map(internalMap) ++ (if(auto) CompilerPlugin :: Nil else Nil)).distinct + ivyConfigurations := { + val confs = thisProject.value.configurations + (confs ++ confs.map(internalConfigurationMap.value) ++ (if(autoCompilerPlugins.value) CompilerPlugin :: Nil else Nil)).distinct }, ivyConfigurations ++= Configurations.auxiliary, moduleSettings <<= moduleSettings0, - makePomConfiguration <<= (artifactPath in makePom, projectInfo, pomExtra, pomPostProcess, pomIncludeRepository, pomAllRepositories) { - (file, minfo, extra, process, include, all) => new MakePomConfiguration(file, minfo, None, extra, process, include, all) - }, - deliverLocalConfiguration <<= (crossTarget, isSnapshot, ivyLoggingLevel) map { (outDir, snapshot, level) => deliverConfig( outDir, status = if (snapshot) "integration" else "release", logging = level ) }, + makePomConfiguration := new MakePomConfiguration(artifactPath in makePom value, projectInfo.value, None, pomExtra.value, pomPostProcess.value, pomIncludeRepository.value, pomAllRepositories.value), + deliverLocalConfiguration := deliverConfig(crossTarget.value, status = if (isSnapshot.value) "integration" else "release", logging = ivyLoggingLevel.value ), deliverConfiguration <<= deliverLocalConfiguration, - publishConfiguration <<= (packagedArtifacts, publishTo, publishMavenStyle, deliver, checksums in publish, ivyLoggingLevel) map { (arts, publishTo, mavenStyle, ivyFile, checks, level) => - publishConfig(arts, if(mavenStyle) None else Some(ivyFile), resolverName = getPublishTo(publishTo).name, checksums = checks, logging = level) - }, - publishLocalConfiguration <<= (packagedArtifacts, deliverLocal, checksums in publishLocal, ivyLoggingLevel) map { - (arts, ivyFile, checks, level) => publishConfig(arts, Some(ivyFile), checks, logging = level ) - }, + publishConfiguration := publishConfig(packagedArtifacts.value, if(publishMavenStyle.value) None else Some(deliver.value), resolverName = getPublishTo(publishTo.value).name, checksums = checksums.in(publish).value, logging = ivyLoggingLevel.value), + publishLocalConfiguration := publishConfig(packagedArtifacts.value, Some(deliverLocal.value), checksums.in(publishLocal).value, logging = ivyLoggingLevel.value ), ivySbt <<= ivySbt0, - ivyModule <<= (ivySbt, moduleSettings) map { (ivySbt, settings) => new ivySbt.Module(settings) }, + ivyModule := { val is = ivySbt.value; new is.Module(moduleSettings.value) }, transitiveUpdate <<= transitiveUpdateTask, update <<= (ivyModule, thisProjectRef, updateConfiguration, cacheDirectory, transitiveUpdate, executionRoots, resolvedScoped, skip in update, streams) map { (module, ref, config, cacheDirectory, reports, roots, resolved, skip, s) => @@ -895,9 +889,7 @@ object Classpaths } tag(Tags.Update, Tags.Network), update <<= (conflictWarning, update, streams) map { (config, report, s) => ConflictWarning(config, report, s.log); report }, transitiveClassifiers in GlobalScope :== Seq(SourceClassifier, DocClassifier), - classifiersModule in updateClassifiers <<= (projectID, update, transitiveClassifiers in updateClassifiers, ivyConfigurations in updateClassifiers) map { ( pid, up, classifiers, confs) => - GetClassifiersModule(pid, up.allModules, confs, classifiers) - }, + classifiersModule in updateClassifiers := GetClassifiersModule(projectID.value, update.value.allModules, ivyConfigurations.in(updateClassifiers).value, transitiveClassifiers.in(updateClassifiers).value), updateClassifiers <<= (ivySbt, classifiersModule in updateClassifiers, updateConfiguration, ivyScala, target in LocalRootProject, appConfiguration, streams) map { (is, mod, c, ivyScala, out, app, s) => withExcludes(out, mod.classifiers, lock(app)) { excludes => IvyActions.updateClassifiers(is, GetClassifiersConfiguration(mod, excludes, c, ivyScala), s.log) diff --git a/main/settings/SettingMacro.scala b/main/settings/SettingMacro.scala index 11442811b..eebb89a2d 100644 --- a/main/settings/SettingMacro.scala +++ b/main/settings/SettingMacro.scala @@ -15,7 +15,7 @@ object InitializeInstance extends MonadInstance } object InitializeConvert extends Convert { - def apply[T: c.AbsTypeTag](c: reflect.macros.Context)(in: c.Tree): c.Tree = + def apply[T: c.WeakTypeTag](c: reflect.macros.Context)(in: c.Tree): c.Tree = { val u = appmacro.ContextUtil[c.type](c) if(in.tpe <:< u.atypeOf[Initialize[Task[T]]] || in.tpe <:< u.atypeOf[Task[T]]) @@ -36,9 +36,9 @@ object InitializeConvert extends Convert object SettingMacro { - def settingMacroImpl[T: c.AbsTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Initialize[T]] = + def settingMacroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Initialize[T]] = Instance.contImpl[T](c, InitializeInstance, InitializeConvert, MixedBuilder)(Left(t)) - def settingDynMacroImpl[T: c.AbsTypeTag](c: Context)(t: c.Expr[Initialize[T]]): c.Expr[Initialize[T]] = + def settingDynMacroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[Initialize[T]]): c.Expr[Initialize[T]] = Instance.contImpl[T](c, InitializeInstance, InitializeConvert, MixedBuilder)(Right(t)) } diff --git a/main/settings/TaskMacro.scala b/main/settings/TaskMacro.scala index b8e2e0606..362576f47 100644 --- a/main/settings/TaskMacro.scala +++ b/main/settings/TaskMacro.scala @@ -41,7 +41,7 @@ object FullInstance extends Instance.Composed[Initialize, Task](InitializeInstan /** Converts an input `Tree` of type `Initialize[T]`, `Initialize[Task[T]]`, or `Task[T]` into a `Tree` of type `Initialize[Task[T]]`.*/ object FullConvert extends Convert { - def apply[T: c.AbsTypeTag](c: Context)(in: c.Tree): c.Tree = + def apply[T: c.WeakTypeTag](c: Context)(in: c.Tree): c.Tree = { val util = appmacro.ContextUtil[c.type](c) if(in.tpe <:< util.atypeOf[Initialize[Task[T]]]) @@ -67,49 +67,49 @@ object TaskMacro final val Append1InitName = "<+=" final val AppendNInitName = "<++=" - def taskMacroImpl[T: c.AbsTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Initialize[Task[T]]] = + def taskMacroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Initialize[Task[T]]] = Instance.contImpl[T](c, FullInstance, FullConvert, MixedBuilder)(Left(t)) - def taskDynMacroImpl[T: c.AbsTypeTag](c: Context)(t: c.Expr[Initialize[Task[T]]]): c.Expr[Initialize[Task[T]]] = + def taskDynMacroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[Initialize[Task[T]]]): c.Expr[Initialize[Task[T]]] = Instance.contImpl[T](c, FullInstance, FullConvert, MixedBuilder)(Right(t)) /** Implementation of := macro for settings. */ - def settingAssignMacroImpl[T: c.AbsTypeTag](c: Context)(v: c.Expr[T]): c.Expr[Setting[T]] = + def settingAssignMacroImpl[T: c.WeakTypeTag](c: Context)(v: c.Expr[T]): c.Expr[Setting[T]] = { val init = SettingMacro.settingMacroImpl[T](c)(v) val assign = transformMacroImpl(c)( init.tree )( AssignInitName ) c.Expr[Setting[T]]( assign ) } /** Implementation of := macro for tasks. */ - def taskAssignMacroImpl[T: c.AbsTypeTag](c: Context)(v: c.Expr[T]): c.Expr[Setting[Task[T]]] = + def taskAssignMacroImpl[T: c.WeakTypeTag](c: Context)(v: c.Expr[T]): c.Expr[Setting[Task[T]]] = { val init = taskMacroImpl[T](c)(v) val assign = transformMacroImpl(c)( init.tree )( AssignInitName ) c.Expr[Setting[Task[T]]]( assign ) } /** Implementation of += macro for tasks. */ - def taskAppend1Impl[T: c.AbsTypeTag, U: c.AbsTypeTag](c: Context)(v: c.Expr[U])(a: c.Expr[Append.Value[T, U]]): c.Expr[Setting[Task[T]]] = + def taskAppend1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context)(v: c.Expr[U])(a: c.Expr[Append.Value[T, U]]): c.Expr[Setting[Task[T]]] = { val init = taskMacroImpl[U](c)(v) val assign = appendMacroImpl(c)( init.tree, a.tree )( Append1InitName ) c.Expr[Setting[Task[T]]]( assign ) } /** Implementation of += macro for settings. */ - def settingAppend1Impl[T: c.AbsTypeTag, U: c.AbsTypeTag](c: Context)(v: c.Expr[U])(a: c.Expr[Append.Value[T, U]]): c.Expr[Setting[T]] = + def settingAppend1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context)(v: c.Expr[U])(a: c.Expr[Append.Value[T, U]]): c.Expr[Setting[T]] = { val init = SettingMacro.settingMacroImpl[U](c)(v) val assign = appendMacroImpl(c)( init.tree, a.tree )( Append1InitName ) c.Expr[Setting[T]]( assign ) } /** Implementation of ++= macro for tasks. */ - def taskAppendNImpl[T: c.AbsTypeTag, U: c.AbsTypeTag](c: Context)(vs: c.Expr[U])(a: c.Expr[Append.Values[T, U]]): c.Expr[Setting[Task[T]]] = + def taskAppendNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context)(vs: c.Expr[U])(a: c.Expr[Append.Values[T, U]]): c.Expr[Setting[Task[T]]] = { val init = taskMacroImpl[U](c)(vs) val assign = appendMacroImpl(c)( init.tree, a.tree )( AppendNInitName ) c.Expr[Setting[Task[T]]]( assign ) } /** Implementation of ++= macro for settings. */ - def settingAppendNImpl[T: c.AbsTypeTag, U: c.AbsTypeTag](c: Context)(vs: c.Expr[U])(a: c.Expr[Append.Values[T, U]]): c.Expr[Setting[T]] = + def settingAppendNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context)(vs: c.Expr[U])(a: c.Expr[Append.Values[T, U]]): c.Expr[Setting[T]] = { val init = SettingMacro.settingMacroImpl[U](c)(vs) val assign = appendMacroImpl(c)( init.tree, a.tree )( AppendNInitName ) @@ -141,7 +141,7 @@ object TaskMacro def value: T = macro std.TaskMacro.valueMacroImpl[T] } - def valueMacroImpl[T: c.AbsTypeTag](c: Context): c.Expr[T] = + def valueMacroImpl[T: c.WeakTypeTag](c: Context): c.Expr[T] = { import c.universe._ c.macroApplication match { @@ -149,7 +149,7 @@ object TaskMacro case x => unexpectedTree(x) } } - private[this] def wrap[T: c.AbsTypeTag](c: Context)(t: c.Tree): c.Expr[T] = + private[this] def wrap[T: c.WeakTypeTag](c: Context)(t: c.Tree): c.Expr[T] = { val ts = c.Expr[Any](t) c.universe.reify { InputWrapper.wrap[T](ts.splice) } @@ -160,7 +160,7 @@ object TaskMacro * This is not used for the main task/setting macros, but could be used when manipulating plain Tasks.*/ object TaskConvert extends Convert { - def apply[T: c.AbsTypeTag](c: Context)(in: c.Tree): c.Tree = + def apply[T: c.WeakTypeTag](c: Context)(in: c.Tree): c.Tree = { val u = appmacro.ContextUtil[c.type](c) if(in.tpe <:< u.atypeOf[Task[T]]) @@ -173,10 +173,10 @@ object TaskConvert extends Convert object PlainTaskMacro { def task[T](t: T): Task[T] = macro taskImpl[T] - def taskImpl[T: c.AbsTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Task[T]] = + def taskImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Task[T]] = Instance.contImpl[T](c, TaskInstance, TaskConvert, MixedBuilder)(Left(t)) def taskDyn[T](t: Task[T]): Task[T] = macro taskDynImpl[T] - def taskDynImpl[T: c.AbsTypeTag](c: Context)(t: c.Expr[Task[T]]): c.Expr[Task[T]] = + def taskDynImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[Task[T]]): c.Expr[Task[T]] = Instance.contImpl[T](c, TaskInstance, TaskConvert, MixedBuilder)(Right(t)) } diff --git a/project/Sbt.scala b/project/Sbt.scala index 67091cff8..19866817e 100644 --- a/project/Sbt.scala +++ b/project/Sbt.scala @@ -16,7 +16,8 @@ object Sbt extends Build organization := "org.scala-sbt", version := "0.13.0-SNAPSHOT", publishArtifact in packageDoc := false, - scalaVersion := "2.10.0-M7", + scalaVersion := "2.10.0-SNAPSHOT", + resolvers += ScalaToolsSnapshots, publishMavenStyle := false, componentID := None, crossPaths := false, @@ -249,6 +250,7 @@ object Sbt extends Build unmanagedJars in Test <<= (packageSrc in compileInterfaceSub in Compile).map(x => Seq(x).classpath) ) def precompiled(scalav: String): Project = baseProject(compilePath / "interface", "Precompiled " + scalav.replace('.', '_')) dependsOn(interfaceSub) settings(precompiledSettings : _*) settings( + scalaHome := None, scalaVersion <<= (scalaVersion in ThisBuild) { sbtScalaV => assert(sbtScalaV != scalav, "Precompiled compiler interface cannot have the same Scala version (" + scalav + ") as sbt.") scalav diff --git a/util/appmacro/ContextUtil.scala b/util/appmacro/ContextUtil.scala index ad66c84e2..3fd45207a 100644 --- a/util/appmacro/ContextUtil.scala +++ b/util/appmacro/ContextUtil.scala @@ -27,7 +27,7 @@ final class ContextUtil[C <: Context](val ctx: C) def getPos(sym: Symbol) = if(sym eq null) NoPosition else sym.pos - def atypeOf[T](implicit att: AbsTypeTag[T]): Type = att.tpe + def atypeOf[T](implicit att: WeakTypeTag[T]): Type = att.tpe /** Constructs a unique term name with the given prefix within this Context. * (The current implementation uses Context.fresh, which increments*/ diff --git a/util/appmacro/Instance.scala b/util/appmacro/Instance.scala index e03a29cb2..1dd51e26b 100644 --- a/util/appmacro/Instance.scala +++ b/util/appmacro/Instance.scala @@ -18,7 +18,7 @@ trait Instance } trait Convert { - def apply[T: c.AbsTypeTag](c: scala.reflect.macros.Context)(in: c.Tree): c.Tree + def apply[T: c.WeakTypeTag](c: scala.reflect.macros.Context)(in: c.Tree): c.Tree } trait MonadInstance extends Instance { @@ -81,7 +81,7 @@ object Instance * this should be the argument wrapped in Right. */ def contImpl[T](c: Context, i: Instance with Singleton, convert: Convert, builder: TupleBuilder)(t: Either[c.Expr[T], c.Expr[i.M[T]]])( - implicit tt: c.AbsTypeTag[T], it: c.TypeTag[i.type]): c.Expr[i.M[T]] = + implicit tt: c.WeakTypeTag[T], it: c.TypeTag[i.type]): c.Expr[i.M[T]] = { import c.universe.{Apply=>ApplyTree,_} @@ -203,7 +203,7 @@ object Instance tree match { case ApplyTree(TypeApply(fun, t :: Nil), qual :: Nil) if isWrapper(fun) => - val tag = c.AbsTypeTag(t.tpe) + val tag = c.WeakTypeTag(t.tpe) addType(t.tpe, convert(c)(qual)(tag) ) case _ => super.transform(tree) }