ca52f554a1/org.scala-refactoring.library/src/main/scala/scala/tools/refactoring/transformation/TreeFactory.scala

Show revision log
 
28048e468f2f0a7b1479d2975df94b27e284e73eca52f554a13ca631512f929d8a0e10ab0cb65831
16
16



17
  object Invisible extends Position
17
  object Invisible extends Position



18
18



19
  def mkRenamedSymTree(t: SymTree, name: String): SymTree = (t match {
19
  def mkRenamedSymTree(t: SymTree, nameString: String): SymTree = {



20
    case i: Ident => i.copy(name = name)
20
    val name = newTermName(nameString)



21
    case v: ValDef => v.copy(name = name)
21
    t match {



22
    case d: DefDef => d.copy(name = name)
22
      case i: Ident => i.copy(name = name)



23
    case b: Bind => b.copy(name = name)
23
      case v: ValDef => v.copy(name = name)



24
    case s: Select => s.copy(name = name)
24
      case d: DefDef => d.copy(name = name)



25
    case c: ClassDef => c.copy(name = name.toTypeName)
25
      case b: Bind => b.copy(name = name)



26
    case t: This => t.copy(qual = name.toTypeName)
26
      case s: Select => s.copy(name = name)



27
    case m: ModuleDef => m.copy(name = name)
27
      case c: ClassDef => c.copy(name = name.toTypeName)



28
    case t: TypeDef => t.copy(name = name.toTypeName)
28
      case t: This => t.copy(qual = name.toTypeName)



29
    case t: PackageDef => t.copy(pid = Ident(name) setPos t.pid.pos)
29
      case m: ModuleDef => m.copy(name = name)



30
    case t => throw new Exception("Found " + t.getClass.getName)
30
      case t: TypeDef => t.copy(name = name.toTypeName)



31
  }) setPos t.pos
31
      case t: PackageDef => t.copy(pid = Ident(name) setPos t.pid.pos)



32
      case t => throw new Exception("Found " + t.getClass.getName)



33
    }



34
  } setPos t.pos



32
35



33
  def mkRenamedTypeTree(t: TypeTree, name: String, originalSymbol: Symbol) = {
36
  def mkRenamedTypeTree(t: TypeTree, name: String, originalSymbol: Symbol) = {



34
    val newType = t.tpe map {
37
    val newType = t.tpe map {


...
...
50
  
53
  



51
  def mkImportFromStrings(qualifier: String, name: String) = {
54
  def mkImportFromStrings(qualifier: String, name: String) = {



52
    def mapPackageNames(qualifier: String) = {
55
    def mapPackageNames(qualifier: String) = {



53
      qualifier.split("\\.").map(s => escapeScalaKeywordsForImport(s.toTermName)).mkString(".")
56
      newTermName(qualifier.split("\\.").map(s => escapeScalaKeywordsForImport(newTermName(s))).mkString("."))



54
    }
57
    }



55
    
58
    



56
    new Import(Ident(mapPackageNames(qualifier)), new ImportSelector(name, -1, name, -1) :: Nil)
59
    new Import(Ident(mapPackageNames(qualifier)), new ImportSelector(newTermName(name), -1, newTermName(name), -1) :: Nil)



57
  }
60
  }



58
61



59
  def mkRenamedImportTree(t: ImportSelectorTree, name: String) =
62
  def mkRenamedImportTree(t: ImportSelectorTree, name: String) =


...
...
71
74



72
  def mkValDef(name: String, rhs: Tree): ValDef = {
75
  def mkValDef(name: String, rhs: Tree): ValDef = {



73
    
76
    



74
    val valDef = ValDef(NoMods, name, new TypeTree, rhs)
77
    val valDef = ValDef(NoMods, newTermName(name), new TypeTree, rhs)



75
    def valDefForFunction = ValDef(NoMods, name, new TypeTree, Apply(rhs, Ident(nme.USCOREkw) :: Nil))
78
    def valDefForFunction = ValDef(NoMods, newTermName(name), new TypeTree, Apply(rhs, Ident(nme.USCOREkw) :: Nil))



76
    
79
    



77
    rhs match {
80
    rhs match {



78
      case rhs: Select if rhs.symbol.isMethod =>
81
      case rhs: Select if rhs.symbol.isMethod =>


...
...
104
          case xs => "(" + (xs map (_.name) mkString ", ") + ")"
107
          case xs => "(" + (xs map (_.name) mkString ", ") + ")"



105
        }
108
        }



106
109



107
        ValDef(NoMods, valName, new TypeTree(), call)
110
        ValDef(NoMods, newTermName(valName), new TypeTree(), call)



108
    }
111
    }



109
  }
112
  }



110
113


...
...
114
      if (parameters.isEmpty)
117
      if (parameters.isEmpty)



115
        Nil
118
        Nil



116
      else
119
      else



117
        parameters map (_ map (s => new ValDef(Modifiers(Flags.PARAM), s.nameString, TypeTree(s.tpe), EmptyTree)))
120
        parameters map (_ map (s => new ValDef(Modifiers(Flags.PARAM), newTermName(s.nameString), TypeTree(s.tpe), EmptyTree)))



118
    }
121
    }



119
122



120
    DefDef(mods withPosition (Flags.METHOD, NoPosition), name, Nil /*type parameters*/ , formalParameters, TypeTree(body.last.tpe), mkBlock(body))
123
    DefDef(mods withPosition (Flags.METHOD, NoPosition), newTermName(name), Nil /*type parameters*/ , formalParameters, TypeTree(body.last.tpe), mkBlock(body))



121
  }
124
  }



122
125



123
  def mkBlock(trees: List[Tree]): Block = trees match {
126
  def mkBlock(trees: List[Tree]): Block = trees match {


...
...
137
140



138
    val constructorArguments = argss map (_ map {
141
    val constructorArguments = argss map (_ map {



139
      case (mods, name, tpe) =>
142
      case (mods, name, tpe) =>



140
        ValDef(mods | Flags.PARAMACCESSOR, name, tpe, EmptyTree)
143
        ValDef(mods | Flags.PARAMACCESSOR, newTermName(name), tpe, EmptyTree)



141
    })
144
    })



142
145



143
    val constructor = {
146
    val constructor = {


...
...
148
          Apply(EmptyTree, args)
151
          Apply(EmptyTree, args)



149
      }
152
      }



150
153



151
      DefDef(mods withPosition (Flags.METHOD, NoPosition), nme.CONSTRUCTOR.toString, Nil, constructorArguments, TypeTree(NoType), mkBlock(body))
154
      DefDef(mods withPosition (Flags.METHOD, NoPosition), nme.CONSTRUCTOR, Nil, constructorArguments, TypeTree(NoType), mkBlock(body))



152
    }
155
    }



153
156



154
    ClassDef(
157
    ClassDef(



155
      mods,
158
      mods,



156
      name.toTypeName,
159
      newTypeName(name),



157
      tparams,
160
      tparams,



158
      Template(
161
      Template(



159
        parents,
162
        parents,


...
...
240
        // copy the tree and delete all positions so the full path will be written
243
        // copy the tree and delete all positions so the full path will be written



241
        val newExpr = topdown(setNoPosition &> removeThisTrees) apply duplicateTree(expr) getOrElse expr
244
        val newExpr = topdown(setNoPosition &> removeThisTrees) apply duplicateTree(expr) getOrElse expr



242
        val typeName = select.symbol.nameString
245
        val typeName = select.symbol.nameString



243
        Some(Import(newExpr, List(new ImportSelector(if(typeName == name.toString) name else typeName, -1, name, -1))))
246
        Some(Import(newExpr, List(new ImportSelector(if(typeName == name.toString) name else newTypeName(typeName), -1, name, -1))))



244
    }
247
    }



245
  }
248
  }



246
}
249
}