could support T : new() like C#?

[Silentdoer]

such as C# code:

class ItemFactory<T> where T : new()
    {
        public T GetNewItem()
        {
            return new T();
        }
    }

it's very useful when we want return a value of T, such as:

class Foo<T> where T : new() {
  T test() {
    return T();
  }
}

[ykmnkmi]

where T: new() accept classes with a default constructor?

[Levi-Lesches]

First of all, you can do this today:

class Foo<T> {
  final T Function() constructor;
  Foo(this.constructor);
  T test() => constructor();
}

or

typedef Constructor<T> = T Function();
class Foo<T> {
  T test(Constructor<T> constructor) => constructor();
}

But to address your request, there has been discussion at #1612 of specifying types by listing the members you want ("structural typing" or "duck typing", similar to what Python uses). A common example is requesting an object with .length. The syntax hasn't been decided on yet -- or even if this should be allowed -- but it could look something like this:

abstract class HasLength {
  int get length;
}

/// Accepts any object with a `.length` property, even if they don't extend [HasLength].
///
/// That means [String], [Map], [List], [Set], etc. all work.
void printLength(HasLength obj) => print(obj.length);
// alternatively: 
void printLength(dynamic<HasLength> obj) => print(obj.length);

What you would want, then, is this:

abstract class Constructor{
  Constructor();
}

class Foo<T extends Constructor> {
  T test() => T();
}
// or 
class Foo<T extends dynamic<Constructor>> {
  T test() => T();
}

Perhaps using the .new syntax from #1564, you can shorten that to:

abstract class Constructor{ new(); }