"Scala no es una clase envolvente"

Question

Al compilar esta especificación:

import org.specs.Specification 
import org.specs.matcher.extension.ParserMatchers 

class ParserSpec extends Specification with ParserMatchers { 
    type Elem = Char 

    "Vaadin DSL parser" should { 
    "parse attributes in parentheses" in { 
     DslParser.attributes must(
     succeedOn(stringReader("""(attr1="val1")""")). 
      withResult(Map[String, AttrVal]("attr1" -> AttrVal("val1", "String")))) 
    } 
    } 
} 

me sale el siguiente error:

ParserSpec.scala:21 
error: scala is not an enclosing class 
withResult(Map[String, AttrVal]("attr1" -> AttrVal("val1", "String")))) 
     ^

No entiendo el mensaje de error aquí en absoluto. ¿Por qué podría aparecer?

La versión de Scala es 2.8.1, la versión de especificaciones es 1.6.7.2.

DslParser.attributes tiene tipo Parser[Map[String, AttrVal]] y los combinadores succeedOn y withResult se definen como sigue:

trait ParserMatchers extends Parsers with Matchers { 
    case class SucceedOn[T](str: Input, 
          resultMatcherOpt: Option[Matcher[T]]) extends Matcher[Parser[T]] { 
    def apply(parserBN: => Parser[T]) = { 
     val parser = parserBN 
     val parseResult = parser(str) 
     parseResult match { 
     case Success(result, remainingInput) => 
      val succParseMsg = "Parser "+parser+" succeeded on input "+str+" with result "+result 
      val okMsgBuffer = new StringBuilder(succParseMsg) 
      val koMsgBuffer = new StringBuilder(succParseMsg) 
      val cond = resultMatcherOpt match { 
      case None => 
       true 
      case Some(resultMatcher) => 
       resultMatcher(result) match { 
       case (success, okMessage, koMessage) => 
        okMsgBuffer.append(" and ").append(okMessage) 
        koMsgBuffer.append(" but ").append(koMessage) 
        success 
       } 
      } 
      (cond, okMsgBuffer.toString, koMsgBuffer.toString) 
     case _ => 
      (false, "Parser succeeded", "Parser "+parser+": "+parseResult) 
     } 
    } 

    def resultMust(resultMatcher: Matcher[T]) = this.copy(resultMatcherOpt = Some(resultMatcher)) 

    def withResult(expectedResult: T) = resultMust(beEqualTo(expectedResult)) 

    def ignoringResult = this.copy(resultMatcherOpt = None) 
    } 

    def succeedOn[T](str: Input, expectedResultOpt: Option[Matcher[T]] = None) = 
    SucceedOn(str, expectedResultOpt) 

    implicit def stringReader(str: String): Reader[Char] = new CharSequenceReader(str) 
} 

Answer 1

Este mensaje puede ocurrir mientras el compilador está realmente tratando de señalar un error de tipo o de un fallo de la inferencia de tipos. Es un error (o familia de errores) en Scalac.

Para localizar el problema, añada progresivamente tipos explícitos y escriba argumentos; romper expresiones complejas en subexpresiones más pequeñas.

Para obtener puntos de bonificación, genere un ejemplo independiente y presente un error.