在带有 jdk 1.7 的 Eclipse Kepler 4.2 中，我在 Eclipse 中遇到以下错误:

The method or(capture#2-of ?) in the type Optional<capture#2-of ?> is not applicable for the arguments (Object)

而它在运行时编译成功 mvn compile .

类如下所示:

package testit;

import java.util.Map;
import java.util.Map.Entry;

import com.google.common.base.Optional;

public class Test {

    private static final Object NO_VALUE = new Object();

    public void method(Map<String, ?> map) {
        for (Entry<String, ?> entry : map.entrySet()) {
            Optional.fromNullable(entry.getValue()).or(NO_VALUE);
//                                                  ^^ error here
        }
    }
}

pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>my.test</groupId>
  <artifactId>testit</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <dependencies>
      <dependency>
          <groupId>com.google.guava</groupId>
          <artifactId>guava</artifactId>
          <version>13.0.1</version>
      </dependency>
  </dependencies>
  <build>
    <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>    
    </plugins>
  </build>
</project>

类似的代码在生产环境中运行了很长时间而没有错误(在这个区域)。它在 Maven、Jenkins、Intelij 中编译，但不在 Eclipse 中编译。问题是为什么它不能在 Eclipse 中编译？

最佳答案

经过 Eclipse 团队的深入分析(顺便说一句，非常感谢!)他们对这个问题的回答如下

在 Stephan Herrmann 之后引用自 Eclipse Bugzilla :

This line doesn't apply for the following reason:

Type inference starts by resolving this expression:

Optional.fromNullable(entry.getValue())

In this expression all elements can be typed as stated above:

entry : Entry entry.getValue:
capture#2-of ? fromNullable(..) : (capture#2-of ?) -> Optional<capture#2-of ?>

In short: T is inferred to be "capture#2-of ?". Inference succeeds.

Only after all these have been decided, does resolution proceed to inspect the .or(..) method call. No reason to fill in un-inferred inference variables with "Object".

With a receiver of type Optional, we have these three overloads of "or":

Optional or(Optional)
capture#2-of ? or(Supplier<? extends capture#2-of ?> supplier)
capture#2-of ? or(capture#2-of ? defaultValue)

None of these methods is applicable for an argument of type Object. ecj arbitrarily picks the first method for error reporting:

"The method or(Optional) in the type Optional is not applicable for the arguments (Object)"

The difference between ecj and javac is most certainly covered by the mentioned javac bug: https://bugs.openjdk.java.net/browse/JDK-8016207

As mentioned in that bug, a future update of the JLS may possibly adopt parts of the current javac behavior. Until such a spec update is released, the only reliable point of reference for ecj is the JLS. In this specification I see no reason for changing the behavior of ecj in this regard.

BTW, the canonical fix (no cast needed) is:

Optional.<Object>fromNullable(entry.getValue()).or(NO_VALUE);

现在这就是结论。

关于java - Eclipse 无法编译通用代码，但 mvn compile 有效，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23006777/