clean up: remove procedure syntax, add return types

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 = ()
   }
 }