clean up: remove procedure syntax, add return types

- deprecated procedure syntax has been removed
- where return types are unambiguous, they have been explicitly added
- where structural types are returned or overridden methods return
  more explicit return type, return type is not annotated (checking
  these would be work for another pull request), to avoid possible
  problems with binary compatibility
- demo and example files have not been touched, yet

Author: Sciss

build.sbt

@@ -15,7 +15,7 @@ scalaVersionsByJvm in ThisBuild := Map(
 
 OsgiKeys.exportPackage := Seq(s"scala.swing.*;version=${version.value}")
 
-mimaPreviousVersion := None
+mimaPreviousVersion := Some("2.0.0")
 
 // set the prompt (for this build) to include the project id.
 shellPrompt in ThisBuild := { state => Project.extract(state).currentRef.project + "> " }

src/main/scala/scala/swing/AbstractButton.scala

@@ -23,65 +23,65 @@ abstract class AbstractButton extends Component with Action.Trigger.Wrapper with
   override lazy val peer: JAbstractButton = new JAbstractButton with SuperMixin {}
 
   def text: String = peer.getText
-  def text_=(s: String) = peer.setText(s)
+  def text_=(s: String): Unit = peer.setText(s)
 
   def icon: Icon = peer.getIcon
-  def icon_=(i: Icon) = peer.setIcon(i)
+  def icon_=(i: Icon): Unit = peer.setIcon(i)
   def pressedIcon: Icon = peer.getPressedIcon
-  def pressedIcon_=(i: Icon) = peer.setPressedIcon(i)
+  def pressedIcon_=(i: Icon): Unit = peer.setPressedIcon(i)
   def selectedIcon: Icon = peer.getSelectedIcon
-  def selectedIcon_=(i: Icon) = peer.setSelectedIcon(i)
+  def selectedIcon_=(i: Icon): Unit = peer.setSelectedIcon(i)
   def disabledIcon: Icon = peer.getDisabledIcon
-  def disabledIcon_=(i: Icon) = peer.setDisabledIcon(i)
+  def disabledIcon_=(i: Icon): Unit = peer.setDisabledIcon(i)
   def disabledSelectedIcon: Icon = peer.getDisabledSelectedIcon
-  def disabledSelectedIcon_=(i: Icon) = peer.setDisabledSelectedIcon(i)
+  def disabledSelectedIcon_=(i: Icon): Unit = peer.setDisabledSelectedIcon(i)
   def rolloverIcon: Icon = peer.getRolloverIcon
-  def rolloverIcon_=(b: Icon) = peer.setRolloverIcon(b)
+  def rolloverIcon_=(b: Icon): Unit = peer.setRolloverIcon(b)
   def rolloverSelectedIcon: Icon = peer.getRolloverSelectedIcon
-  def rolloverSelectedIcon_=(b: Icon) = peer.setRolloverSelectedIcon(b)
+  def rolloverSelectedIcon_=(b: Icon): Unit = peer.setRolloverSelectedIcon(b)
 
-  peer.addActionListener(Swing.ActionListener { e =>
+  peer.addActionListener(Swing.ActionListener { _ =>
     publish(ButtonClicked(AbstractButton.this))
   })
 
   def selected: Boolean = peer.isSelected
-  def selected_=(b: Boolean) = peer.setSelected(b)
+  def selected_=(b: Boolean): Unit = peer.setSelected(b)
 
   def contentAreaFilled: Boolean = peer.isContentAreaFilled
-  def contentAreaFilled_=(b: Boolean) { peer.setContentAreaFilled(b) }
+  def contentAreaFilled_=(b: Boolean): Unit = peer.setContentAreaFilled(b)
 
   def borderPainted: Boolean = peer.isBorderPainted
-  def borderPainted_=(b: Boolean) { peer.setBorderPainted(b) }
+  def borderPainted_=(b: Boolean): Unit = peer.setBorderPainted(b)
   def focusPainted: Boolean = peer.isFocusPainted
-  def focusPainted_=(b: Boolean) { peer.setFocusPainted(b) }
+  def focusPainted_=(b: Boolean): Unit = peer.setFocusPainted(b)
 
   def rolloverEnabled: Boolean = peer.isRolloverEnabled
-  def rolloverEnabled_=(b: Boolean) = peer.setRolloverEnabled(b)
+  def rolloverEnabled_=(b: Boolean): Unit = peer.setRolloverEnabled(b)
 
   def verticalTextPosition: Alignment.Value = Alignment(peer.getVerticalTextPosition)
-  def verticalTextPosition_=(a: Alignment.Value) { peer.setVerticalTextPosition(a.id) }
+  def verticalTextPosition_=(a: Alignment.Value): Unit = peer.setVerticalTextPosition(a.id)
   def verticalAlignment: Alignment.Value = Alignment(peer.getVerticalAlignment)
-  def verticalAlignment_=(a: Alignment.Value) { peer.setVerticalAlignment(a.id) }
+  def verticalAlignment_=(a: Alignment.Value): Unit = peer.setVerticalAlignment(a.id)
 
   def horizontalTextPosition: Alignment.Value = Alignment(peer.getHorizontalTextPosition)
-  def horizontalTextPosition_=(a: Alignment.Value) { peer.setHorizontalTextPosition(a.id) }
+  def horizontalTextPosition_=(a: Alignment.Value): Unit = peer.setHorizontalTextPosition(a.id)
   def horizontalAlignment: Alignment.Value = Alignment(peer.getHorizontalAlignment)
-  def horizontalAlignment_=(a: Alignment.Value) { peer.setHorizontalAlignment(a.id) }
+  def horizontalAlignment_=(a: Alignment.Value): Unit = peer.setHorizontalAlignment(a.id)
 
   def iconTextGap: Int = peer.getIconTextGap
-  def iconTextGap_=(x: Int) { peer.setIconTextGap(x) }
+  def iconTextGap_=(x: Int): Unit = peer.setIconTextGap(x)
 
   def mnemonic: Key.Value = Key(peer.getMnemonic)
-  def mnemonic_=(k: Key.Value) { peer.setMnemonic(k.id) }
+  def mnemonic_=(k: Key.Value): Unit = peer.setMnemonic(k.id)
   def displayedMnemonicIndex: Int = peer.getDisplayedMnemonicIndex
-  def displayedMnemonicIndex_=(n: Int) { peer.setDisplayedMnemonicIndex(n) }
+  def displayedMnemonicIndex_=(n: Int): Unit = peer.setDisplayedMnemonicIndex(n)
 
   def multiClickThreshold: Long = peer.getMultiClickThreshhold
-  def multiClickThreshold_=(n: Long) { peer.setMultiClickThreshhold(n) }
+  def multiClickThreshold_=(n: Long): Unit = peer.setMultiClickThreshhold(n)
 
-  def doClick() { peer.doClick() }
-  def doClick(times: Int) { peer.doClick(times) }
+  def doClick(): Unit = peer.doClick()
+  def doClick(times: Int): Unit = peer.doClick(times)
 
   def margin: Insets = peer.getMargin
-  def margin_=(i: Insets) { peer.setMargin(i) }
+  def margin_=(i: Insets): Unit = peer.setMargin(i)
 }

src/main/scala/scala/swing/Action.scala

@@ -21,21 +21,21 @@ object Action {
    * instead of from its action.
    * In Java Swing, one would use `null` instead of a designated action.
    */
-  case object NoAction extends Action("") { def apply() {} }
+  case object NoAction extends Action("") { def apply(): Unit = () }
 
   object Trigger {
     trait Wrapper extends Action.Trigger {
       def peer: javax.swing.JComponent {
-        def addActionListener(a: ActionListener)
-        def removeActionListener(a: ActionListener)
-        def setAction(a: javax.swing.Action)
+        def addActionListener(a: ActionListener): Unit
+        def removeActionListener(a: ActionListener): Unit
+        def setAction(a: javax.swing.Action): Unit
         def getAction(): javax.swing.Action
       }
 
       // TODO: we need an action cache
       private var _action: Action = Action.NoAction
       def action: Action = _action
-      def action_=(a: Action) { _action = a; peer.setAction(a.peer) }
+      def action_=(a: Action): Unit = { _action = a; peer.setAction(a.peer) }
 
       //1.6: def hideActionText: Boolean = peer.getHideActionText
       //def hideActionText_=(b: Boolean) = peer.setHideActionText(b)
@@ -47,7 +47,7 @@ object Action {
    */
   trait Trigger {
     def action: Action
-    def action_=(a: Action)
+    def action_=(a: Action): Unit
 
     //1.6: def hideActionText: Boolean
     //def hideActionText_=(b: Boolean)
@@ -56,8 +56,8 @@ object Action {
   /**
    * Convenience method to create an action with a given title and body to run.
    */
-  def apply(title: String)(body: =>Unit) = new Action(title) {
-    def apply() { body }
+  def apply(title: String)(body: => Unit): Action = new Action(title) {
+    def apply(): Unit = body
   }
 }
 
@@ -75,49 +75,48 @@ abstract class Action(title0: String) {
   import Swing._
 
   lazy val peer: javax.swing.Action = new javax.swing.AbstractAction(title0) {
-    def actionPerformed(a: java.awt.event.ActionEvent) = apply()
+    def actionPerformed(a: java.awt.event.ActionEvent): Unit = apply()
   }
 
   /**
    * Title is not optional.
    */
   def title: String = ifNull(peer.getValue(javax.swing.Action.NAME),"")
-  def title_=(t: String) { peer.putValue(javax.swing.Action.NAME, t) }
+  def title_=(t: String): Unit = peer.putValue(javax.swing.Action.NAME, t)
 
   /**
    * None if large icon and small icon are not equal.
    */
   def icon: Icon = smallIcon //if(largeIcon == smallIcon) largeIcon else None
-  def icon_=(i: Icon) { /*largeIcon = i;*/ smallIcon = i }
+  def icon_=(i: Icon): Unit = /*largeIcon = i;*/ smallIcon = i
   // 1.6: def largeIcon: Icon = toNoIcon(peer.getValue(javax.swing.Action.LARGE_ICON_KEY).asInstanceOf[Icon])
   // def largeIcon_=(i: Icon) { peer.putValue(javax.swing.Action.LARGE_ICON_KEY, toNullIcon(i)) }
   def smallIcon: Icon = toNoIcon(peer.getValue(javax.swing.Action.SMALL_ICON).asInstanceOf[Icon])
-  def smallIcon_=(i: Icon) { peer.putValue(javax.swing.Action.SMALL_ICON, toNullIcon(i)) }
+  def smallIcon_=(i: Icon): Unit = peer.putValue(javax.swing.Action.SMALL_ICON, toNullIcon(i))
 
   /**
    * For all components.
    */
   def toolTip: String =
     ifNull(peer.getValue(javax.swing.Action.SHORT_DESCRIPTION), "")
-  def toolTip_=(t: String) {
+  def toolTip_=(t: String): Unit =
     peer.putValue(javax.swing.Action.SHORT_DESCRIPTION, t)
-  }
+
   /**
    * Can be used for status bars, for example.
    */
   def longDescription: String =
     ifNull(peer.getValue(javax.swing.Action.LONG_DESCRIPTION), "")
-  def longDescription_=(t: String) {
+  def longDescription_=(t: String): Unit =
     peer.putValue(javax.swing.Action.LONG_DESCRIPTION, t)
-  }
 
   /**
    * Default: java.awt.event.KeyEvent.VK_UNDEFINED, i.e., no mnemonic key.
    * For all buttons and thus menu items.
    */
   def mnemonic: Int = ifNull(peer.getValue(javax.swing.Action.MNEMONIC_KEY),
                              java.awt.event.KeyEvent.VK_UNDEFINED)
-  def mnemonic_=(m: Int) { peer.putValue(javax.swing.Action.MNEMONIC_KEY, m) }
+  def mnemonic_=(m: Int): Unit = peer.putValue(javax.swing.Action.MNEMONIC_KEY, m)
 
   /*/**
    * Indicates which character of the title should be underlined to indicate the mnemonic key.
@@ -134,15 +133,14 @@ abstract class Action(title0: String) {
    */
   def accelerator: Option[KeyStroke] =
     toOption(peer.getValue(javax.swing.Action.ACCELERATOR_KEY))
-  def accelerator_=(k: Option[KeyStroke]) {
+  def accelerator_=(k: Option[KeyStroke]): Unit =
     peer.putValue(javax.swing.Action.ACCELERATOR_KEY, k.orNull)
-  }
 
   /**
    * For all components.
    */
   def enabled: Boolean = peer.isEnabled
-  def enabled_=(b: Boolean) { peer.setEnabled(b) }
+  def enabled_=(b: Boolean): Unit = peer.setEnabled(b)
 
   /*/**
    * Only honored if not <code>None</code>. For various buttons.
@@ -153,5 +151,5 @@ abstract class Action(title0: String) {
                  if (b == None) null else new java.lang.Boolean(b.get))
   }*/
 
-  def apply()
+  def apply(): Unit
 }

src/main/scala/scala/swing/Adjustable.scala

@@ -6,40 +6,40 @@ object Adjustable {
   trait Wrapper extends Oriented.Wrapper with Adjustable {
     def peer: JAdjustable with OrientedMixin
 
-    def unitIncrement = peer.getUnitIncrement
-    def unitIncrement_=(i: Int) = peer.setUnitIncrement(i)
-    def blockIncrement = peer.getBlockIncrement
-    def blockIncrement_=(i: Int) = peer.setBlockIncrement(i)
+    def unitIncrement: Int = peer.getUnitIncrement
+    def unitIncrement_=(i: Int): Unit = peer.setUnitIncrement(i)
+    def blockIncrement: Int = peer.getBlockIncrement
+    def blockIncrement_=(i: Int): Unit = peer.setBlockIncrement(i)
 
-    def value = peer.getValue
-    def value_=(v: Int) = peer.setValue(v)
+    def value: Int = peer.getValue
+    def value_=(v: Int): Unit = peer.setValue(v)
 
-    def visibleAmount = peer.getVisibleAmount
-    def visibleAmount_=(v: Int) = peer.setVisibleAmount(v)
+    def visibleAmount: Int = peer.getVisibleAmount
+    def visibleAmount_=(v: Int): Unit = peer.setVisibleAmount(v)
 
-    def minimum = peer.getMinimum
-    def minimum_=(m: Int) = peer.setMinimum(m)
-    def maximum = peer.getMaximum
-    def maximum_=(m: Int) = peer.setMaximum(m)
+    def minimum: Int = peer.getMinimum
+    def minimum_=(m: Int): Unit = peer.setMinimum(m)
+    def maximum: Int = peer.getMaximum
+    def maximum_=(m: Int): Unit = peer.setMaximum(m)
   }
 }
 
 trait Adjustable extends Oriented {
   def unitIncrement: Int
-  def unitIncrement_=(i: Int)
+  def unitIncrement_=(i: Int): Unit
   def blockIncrement: Int
-  def blockIncrement_=(i: Int)
+  def blockIncrement_=(i: Int): Unit
 
   def value: Int
-  def value_=(v : Int)
+  def value_=(v : Int): Unit
 
   def visibleAmount: Int
-  def visibleAmount_=(v: Int)
+  def visibleAmount_=(v: Int): Unit
 
   def minimum: Int
-  def minimum_=(m: Int)
+  def minimum_=(m: Int): Unit
   def maximum: Int
-  def maximum_=(m: Int)
+  def maximum_=(m: Int): Unit
 
 // Needs implementation of AdjustmentEvent
 //

src/main/scala/scala/swing/Alignment.scala

@@ -10,23 +10,22 @@
 
 package scala.swing
 
-import javax.swing.SwingConstants._
-
 /**
  * Horizontal and vertical alignments. We sacrifice a bit of type-safety
  * for simplicity here.
  *
  * @see javax.swing.SwingConstants
  */
 object Alignment extends Enumeration {
-  val Left = Value(LEFT)
-  val Right = Value(RIGHT)
-  val Center = Value(CENTER)
-  val Top = Value(TOP)
-  val Bottom = Value(BOTTOM)
+  import javax.swing.SwingConstants._
+  val Left    : Alignment.Value = Value(LEFT)
+  val Right   : Alignment.Value = Value(RIGHT)
+  val Center  : Alignment.Value = Value(CENTER)
+  val Top     : Alignment.Value = Value(TOP)
+  val Bottom  : Alignment.Value = Value(BOTTOM)
   //1.6: val Baseline = Value(BASELINE)
 
-  val Leading = Value(LEADING)
-  val Trailing = Value(TRAILING)
+  val Leading : Alignment.Value = Value(LEADING)
+  val Trailing: Alignment.Value = Value(TRAILING)
 }
 

src/main/scala/scala/swing/Applet.scala

@@ -27,20 +27,20 @@ import javax.swing.JApplet
 abstract class Applet extends JApplet { outer =>
   val ui: UI
 
-  override def init() { ui.init() }
-  override def start() { ui.start() }
-  override def stop() { ui.stop() }
+  override def init (): Unit = ui.init ()
+  override def start(): Unit = ui.start()
+  override def stop (): Unit = ui.stop ()
 
   abstract class UI extends RootPanel {
-    def peer = outer
-    override def contents_=(c: Component) {
+    def peer: Applet = outer
+    override def contents_=(c: Component): Unit = {
       super.contents_=(c)
       peer.validate()
     }
 
-    def init()
-    def start() {}
-    def stop() {}
+    def init (): Unit
+    def start(): Unit = ()
+    def stop (): Unit = ()
   }
 }