Error with property in interface implemented by a record

[EotT123]

When defining a property in an interface using the @val syntax, implementing that interface with a record fails due to changed getter names for records.

public interface MyInterface {
    // Using property syntax causes issues:
    @val String foo;
}

// ERROR: Class 'test' must implement abstract method 'getFoo()' in 'MyInterface'
public record TestRecord(String foo) implements MyInterface { }

Changing MyInterface to use a standard getter method resolves the issue, but it means I can no longer access the property directly and must instead use the getter:

public interface MyInterface {
    String foo();
}

[rsmckinney]

This one's a bit tough.

First off, properties already support records where you reference record components using property syntax:

public record TestRecord(String foo) {}

TestRecord test = new TestRecord("hi");
String foo = test.foo; // access as properties

That might make it seem like record access methods should implement properties too, but as you've discovered, they don't.

The trouble is, record methods can't directly override getter methods. To make this work, Manifold would have to step in and generate getter methods that forward to record methods. Early on I avoided that because at the time it felt too invasive. Now that I'm revisiting the idea, I feel less opposed to it.

Still, you can always write the getters manually when you need to:

public interface MyInterface {
    @val String foo;
}

public record TestRecord(String foo) implements MyInterface { 
  public String getFoo() {
    return foo();
  }
}

Hope that helps! I'll give some more thought to auto-generating the forwarding getters too.

[EotT123]

Thank you for the explanation and suggestion.

I find it a bit counterintuitive that implementing an interface with both a record and a regular class requires different code. I hadn't considered your proposed workaround and had reverted to using a standard getter, but your solution is definitely more effective.

While it may not be intuitive, your workaround allows me to utilize properties, which I appreciate.

Generating the getters automatically seems to be a good way to handle the problem.