What's the purpose of allowing the declaration of an abstract method in a non-abstract class?

Question

According to this article, it's possible, in Dart, to define a non-abstract class to have an abstract (or not-implemented) method. The abstract method causes a warning, but does not prevent instantiation.

What's the purpose of allowing the declaration of an abstract method in a non-abstract (or concrete) class in Dart? Why was Dart designed to work in this way?

Answer 1

The specification is actually very explicit about declaring abstract methods in a concrete class:

It is a static warning if an abstract member m is declared or inherited in a concrete class

---

We wish to warn if one declares a concrete class with abstract members.

---

It is a static warning if a concrete class has an abstract member (declared or inherited).

They don't have any intended purpose for it, which is why they issue warnings. If you're familiar with Java: it's similar to accessing a static member via an object, which is also pointless and triggers a warning.

As for why it passes compilation, Dart uses an optional type system, which means typing concepts should not affect the semantics of the language, and that's simply what Dart is enforcing:

The purpose of an abstract method is to provide a declaration for purposes such as type checking and reflection.

---

The static checker will report some violations of the type rules, but such violations do not abort compilation or preclude execution.

Answer 2

An abstract method in a concrete class allows you to provide the type signature for a method that is implemented via noSuchMethod() instead. Providing a noSuchMethod() implementation will also silence the warning.

In strong mode, simply having an abstract method in a concrete class will result in an error, unless the class also implements the noSuchMethod() interface.

In short, the purpose of abstract methods in a concrete class is to provide type signatures for noSuchMethod() implementations. This avoids warnings for calling an unknown method and in strong mode (which is the default for dartdevc, and will be first the default and then mandatory for Dart 2.0) these type signatures are necessary for code with noSuchMethod() to even compile, unless the target is of type dynamic.

Example:

class A {
  void f();
  dynamic noSuchMethod(Invocation inv) => null;
}

void main() {
  var a = new A();
  a.f();
}

If we replace a.f() with (say) a.f(0), then this will result in an error (in strong mode) for having called the method with the wrong number of parameters. If we omit the void f() declaration, then we'll get an error that A does not have a method f(). If we omit the noSuchMethod() implementation, then the complaint will be that f() lacks a method body, even though A isn't abstract.

The following code provides a more realistic example:

import "dart:mirrors";

class DebugList<T> implements List<T> {
  List<T> _delegate;
  InstanceMirror _mirror;
  DebugList(this._delegate) {
    _mirror = reflect(_delegate);
  }
  dynamic noSuchMethod(Invocation inv) {
    print("entering ${inv.memberName}");
    var result = _mirror.delegate(inv);
    print("leaving  ${inv.memberName}");
    return result;
  }
}

void main() {
  List<int> list = new DebugList<int>([1, 2, 3]);
  int len = list.length;
  for (int i = 0; i < len; i++) print(list[i]);
}

This example creates a debugging decorator for List<T>, showing all method invocations. We use implements List<T> to pull in the entire list interface, inheriting dozens of abstract methods. This would normally result in warnings (or in strong mode, errors) when run through dartanalyzer, as we're missing implementations for all these methods normally provided by List<T>. Providing a noSuchMethod() implementation silences these warnings/errors.

While we could also manually wrap all 50+ methods, this would be a lot of typing. The above approach also will continue to work if new methods are added to the list interface without us having to change our code.

Use cases for explicitly listing methods in a concrete class are less common, but can also occur. An example would be the addition of getters or setters to such a debugging decorator that allows us to inspect or set instance variables of the delegate. We will need to add them to the interface, anyway, to avoid warnings and errors from using them; the noSuchMethod() implementation can then implement them using getField() and setField(). Here's a variant of the previous example, using stacks instead of lists:

// main.dart

import "dart:mirrors";
import "stack.dart";

class DebugStack<T> implements Stack<T> {
  Stack<T> _delegate;
  InstanceMirror _mirror;
  DebugStack(this._delegate) {
    _mirror = reflect(_delegate);
  }

  dynamic _get(Symbol sym) {
    // some magic so that we can retrieve private fields
    var name = MirrorSystem.getName(sym);
    var sym2 = MirrorSystem.getSymbol(name, _mirror.type.owner);
    return _mirror.getField(sym2).reflectee;
  }

  List<T> get _data;

  dynamic noSuchMethod(Invocation inv) {
    dynamic result;
    print("entering ${inv.memberName}");
    if (inv.isGetter)
      result = _get(inv.memberName);
    else
      result = _mirror.delegate(inv);
    print("leaving  ${inv.memberName}");
    return result;
  }
}

void main() {
  var stack = new DebugStack<int>(new Stack<int>.from([1, 2, 3]));
  print(stack._data);
  while (!stack.isEmpty) {
    print(stack.pop());
  }
}

// stack.dart

class Stack<T> {
  List<T> _data = [];
  Stack.empty();
  Stack.from(Iterable<T> src) {
    _data.addAll(src);
  }
  void push(T item) => _data.add(item);
  T pop() => _data.removeLast();
  bool get isEmpty => _data.length == 0;
}

Note that the abstract declaration of the _data getter is crucial for type checking. If we were to remove it, we'd get a warning even without strong mode, and in strong mode (say, with dartdevc or dartanalyzer --strong), it will fail:

$ dartdevc -o main.js main.dart
[error] The getter '_data' isn't defined for the class 'DebugStack<int>' (main.dart, line 36, col 15)

Please fix all errors before compiling (warnings are okay).