6679978779

Committed 27 Oct 2023 12:38AM UTC coverage: 92.169% (-0.09%) from 92.254%

Build # 6679978779

Build Type

push

github

Committed by

web-flow

Commit Message

Use getDartType rather than getFfiDartType in ObjC block codegen (#632)

* Blocks returning proper user facing types

* More tests and refactors

* fmt

* Fix test

* Fix vararg test

* Partial fix for block ref counts

* More block ref counting fixes

* fmt

* Daco's comments

Run Details

102 of 102 new or added lines in 7 files covered. (100.0%)

3719 of 4035 relevant lines covered (92.17%)

28.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.59

/lib/src/code_generator/func_type.dart

// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:ffigen/src/code_generator.dart';
import 'package:ffigen/src/code_generator/utils.dart';

import 'writer.dart';

/// Represents a function type.
class FunctionType extends Type {
  final Type returnType;
  final List<Parameter> parameters;
  final List<Parameter> varArgParameters;

  /// Get all the parameters for generating the dart type. This includes both
  /// [parameters] and [varArgParameters].
  List<Parameter> get dartTypeParameters => parameters + varArgParameters;

  FunctionType({
    required this.returnType,
    required this.parameters,
    this.varArgParameters = const [],
  });

  String _getTypeImpl(
      bool writeArgumentNames, String Function(Type) typeToString,
      {String? varArgWrapper}) {
    final params = varArgWrapper != null ? parameters : dartTypeParameters;
    String? varArgPack;
    if (varArgWrapper != null && varArgParameters.isNotEmpty) {
      final varArgPackBuf = StringBuffer();
      varArgPackBuf.write("$varArgWrapper<(");
      varArgPackBuf.write((varArgParameters).map<String>((p) {
        return '${typeToString(p.type)} ${writeArgumentNames ? p.name : ""}';
      }).join(', '));
      varArgPackBuf.write(",)>");
      varArgPack = varArgPackBuf.toString();
    }

    // Write return Type.
    final sb = StringBuffer();
    sb.write(typeToString(returnType));

    // Write Function.
    sb.write(' Function(');
    sb.write([
      ...params.map<String>((p) {
        return '${typeToString(p.type)} ${writeArgumentNames ? p.name : ""}';
      }),
      if (varArgPack != null) varArgPack,
    ].join(', '));
    sb.write(')');

    return sb.toString();
  }

  @override
  String getCType(Writer w, {bool writeArgumentNames = true}) =>
      _getTypeImpl(writeArgumentNames, (Type t) => t.getCType(w),
          varArgWrapper: '${w.ffiLibraryPrefix}.VarArgs');

  @override
  String getFfiDartType(Writer w, {bool writeArgumentNames = true}) =>
      _getTypeImpl(writeArgumentNames, (Type t) => t.getFfiDartType(w));

  @override
  String getDartType(Writer w, {bool writeArgumentNames = true}) =>
      _getTypeImpl(writeArgumentNames, (Type t) => t.getDartType(w));

  @override
  bool get sameFfiDartAndCType =>
      returnType.sameFfiDartAndCType &&
      dartTypeParameters.every((p) => p.type.sameFfiDartAndCType);

  @override
  bool get sameDartAndCType =>
      returnType.sameDartAndCType &&
      dartTypeParameters.every((p) => p.type.sameDartAndCType);

  @override
  String toString() => _getTypeImpl(false, (Type t) => t.toString());

  @override
  String cacheKey() => _getTypeImpl(false, (Type t) => t.cacheKey());

  @override
  void addDependencies(Set<Binding> dependencies) {
    returnType.addDependencies(dependencies);
    for (final p in parameters) {
      p.type.addDependencies(dependencies);
    }
  }

  void addParameterNames(List<String> names) {
    if (names.length != parameters.length) {
      return;
    }
    final paramNamer = UniqueNamer({});
    for (int i = 0; i < parameters.length; i++) {
      final finalName = paramNamer.makeUnique(names[i]);
      parameters[i] = Parameter(
        type: parameters[i].type,
        originalName: names[i],
        name: finalName,
      );
    }
  }
}

/// Represents a NativeFunction<Function>.
class NativeFunc extends Type {
  // Either a FunctionType or a Typealias of a FunctionType.
  final Type _type;

  NativeFunc(this._type) {
    assert(_type is FunctionType || _type is Typealias);
  }

  FunctionType get type {
    if (_type is Typealias) {
      return _type.typealiasType as FunctionType;
    }
    return _type as FunctionType;
  }

  @override
  void addDependencies(Set<Binding> dependencies) {
    _type.addDependencies(dependencies);
  }

  @override
  String getCType(Writer w) =>
      '${w.ffiLibraryPrefix}.NativeFunction<${_type.getCType(w)}>';

  @override
  String getFfiDartType(Writer w) => getCType(w);

  @override
  bool get sameFfiDartAndCType => true;

  @override
  String toString() => 'NativeFunction<${_type.toString()}>';

  @override
  String cacheKey() => 'NatFn(${_type.cacheKey()})';
}

1	// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
2	// for details. All rights reserved. Use of this source code is governed by a
3	// BSD-style license that can be found in the LICENSE file.
4
5	import 'package:ffigen/src/code_generator.dart';
6	import 'package:ffigen/src/code_generator/utils.dart';
7
8	import 'writer.dart';
9
10	/// Represents a function type.
11	class FunctionType extends Type {
12	final Type returnType;
13	final List<Parameter> parameters;
14	final List<Parameter> varArgParameters;
15
16	/// Get all the parameters for generating the dart type. This includes both
17	/// [parameters] and [varArgParameters].
18	List<Parameter> get dartTypeParameters => parameters + varArgParameters;	112✔
19
20	FunctionType({	30✔
21	required this.returnType,
22	required this.parameters,
23	this.varArgParameters = const [],
24	});
25
26	String _getTypeImpl(	28✔
27	bool writeArgumentNames, String Function(Type) typeToString,
28	{String? varArgWrapper}) {
29	final params = varArgWrapper != null ? parameters : dartTypeParameters;	56✔
30	String? varArgPack;
31	if (varArgWrapper != null && varArgParameters.isNotEmpty) {	56✔
32	final varArgPackBuf = StringBuffer();	1✔
33	varArgPackBuf.write("$varArgWrapper<(");	2✔
34	varArgPackBuf.write((varArgParameters).map<String>((p) {	4✔
35	return '${typeToString(p.type)} ${writeArgumentNames ? p.name : ""}';	3✔
36	}).join(', '));	1✔
37	varArgPackBuf.write(",)>");	1✔
38	varArgPack = varArgPackBuf.toString();	1✔
39	}
40
41	// Write return Type.
42	final sb = StringBuffer();	28✔
43	sb.write(typeToString(returnType));	84✔
44
45	// Write Function.
46	sb.write(' Function(');	28✔
47	sb.write([	56✔
48	...params.map<String>((p) {	52✔
49	return '${typeToString(p.type)} ${writeArgumentNames ? p.name : ""}';	82✔
50	}),
51	if (varArgPack != null) varArgPack,	1✔
52	].join(', '));	28✔
53	sb.write(')');	28✔
54
55	return sb.toString();	28✔
56	}
57
58	@override	28✔
59	String getCType(Writer w, {bool writeArgumentNames = true}) =>
60	_getTypeImpl(writeArgumentNames, (Type t) => t.getCType(w),	84✔
61	varArgWrapper: '${w.ffiLibraryPrefix}.VarArgs');	56✔
62
63	@override	27✔
64	String getFfiDartType(Writer w, {bool writeArgumentNames = true}) =>
65	_getTypeImpl(writeArgumentNames, (Type t) => t.getFfiDartType(w));	81✔
66
67	@override	8✔
68	String getDartType(Writer w, {bool writeArgumentNames = true}) =>
69	_getTypeImpl(writeArgumentNames, (Type t) => t.getDartType(w));	24✔
70
71	@override	×
72	bool get sameFfiDartAndCType =>
73	returnType.sameFfiDartAndCType &&	×
74	dartTypeParameters.every((p) => p.type.sameFfiDartAndCType);	×
75
76	@override	6✔
77	bool get sameDartAndCType =>
78	returnType.sameDartAndCType &&	12✔
79	dartTypeParameters.every((p) => p.type.sameDartAndCType);	2✔
80
81	@override	2✔
82	String toString() => _getTypeImpl(false, (Type t) => t.toString());	6✔
83
84	@override	2✔
85	String cacheKey() => _getTypeImpl(false, (Type t) => t.cacheKey());	6✔
86
87	@override	30✔
88	void addDependencies(Set<Binding> dependencies) {
89	returnType.addDependencies(dependencies);	60✔
90	for (final p in parameters) {	55✔
91	p.type.addDependencies(dependencies);	50✔
92	}
93	}
94
95	void addParameterNames(List<String> names) {	8✔
96	if (names.length != parameters.length) {	32✔
97	return;
98	}
99	final paramNamer = UniqueNamer({});	7✔
100	for (int i = 0; i < parameters.length; i++) {	27✔
101	final finalName = paramNamer.makeUnique(names[i]);	12✔
102	parameters[i] = Parameter(	18✔
103	type: parameters[i].type,	18✔
104	originalName: names[i],	6✔
105	name: finalName,
106	);
107	}
108	}
109	}
110
111	/// Represents a NativeFunction<Function>.
112	class NativeFunc extends Type {
113	// Either a FunctionType or a Typealias of a FunctionType.
114	final Type _type;
115
116	NativeFunc(this._type) {	11✔
117	assert(_type is FunctionType \|\| _type is Typealias);	34✔
118	}
119
120	FunctionType get type {	7✔
121	if (_type is Typealias) {	14✔
122	return _type.typealiasType as FunctionType;	2✔
123	}
124	return _type as FunctionType;	7✔
125	}
126
127	@override	11✔
128	void addDependencies(Set<Binding> dependencies) {
129	_type.addDependencies(dependencies);	22✔
130	}
131
132	@override	11✔
133	String getCType(Writer w) =>
134	'${w.ffiLibraryPrefix}.NativeFunction<${_type.getCType(w)}>';	44✔
135
136	@override	2✔
137	String getFfiDartType(Writer w) => getCType(w);	2✔
138
139	@override	1✔
140	bool get sameFfiDartAndCType => true;
141
142	@override	2✔
143	String toString() => 'NativeFunction<${_type.toString()}>';	6✔
144
145	@override	2✔
146	String cacheKey() => 'NatFn(${_type.cacheKey()})';	6✔
147	}

dart-lang / ffigen / 6679978779

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous