6470767942

Committed 10 Oct 2023 02:29PM UTC coverage: 91.966% (-0.6%) from 92.593%

Build # 6470767942

Build Type

push

github

Committed by

web-flow

Commit Message

Refactor `sameFfiDartAndCType` to not require a `Writer` (#629)

Run Details

40 of 40 new or added lines in 12 files covered. (100.0%)

3709 of 4033 relevant lines covered (91.97%)

28.07 hits per line

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

88.16

/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 _getCacheKeyString(
      bool writeArgumentNames, String Function(Type) typeToString) {
    final sb = StringBuffer();

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

    // Write Function.
    sb.write(' Function(');
    sb.write(parameters.map<String>((p) {
      return '${typeToString(p.type)} ${writeArgumentNames ? p.name : ""}';
    }).join(', '));
    sb.write(')');

    return sb.toString();
  }

  @override
  String getCType(Writer w, {bool writeArgumentNames = true}) {
    final sb = StringBuffer();

    // Write return Type.
    sb.write(returnType.getCType(w));

    // Write Function.
    sb.write(' Function(');
    sb.write((parameters).map<String>((p) {
      return '${p.type.getCType(w)} ${writeArgumentNames ? p.name : ""}';
    }).join(', '));
    if (varArgParameters.isNotEmpty) {
      sb.write(", ${w.ffiLibraryPrefix}.VarArgs<(");
      sb.write((varArgParameters).map<String>((p) {
        return '${p.type.getCType(w)} ${writeArgumentNames ? p.name : ""}';
      }).join(', '));
      sb.write(",)>");
    }
    sb.write(')');

    return sb.toString();
  }

  @override
  String getFfiDartType(Writer w, {bool writeArgumentNames = true}) {
    final sb = StringBuffer();

    // Write return Type.
    sb.write(returnType.getFfiDartType(w));

    // Write Function.
    sb.write(' Function(');
    sb.write(dartTypeParameters.map<String>((p) {
      return '${p.type.getFfiDartType(w)} ${writeArgumentNames ? p.name : ""}';
    }).join(', '));
    sb.write(')');

    return sb.toString();
  }

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

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

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

  @override
  String cacheKey() => _getCacheKeyString(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;	108✔
19
20	FunctionType({	30✔
21	required this.returnType,
22	required this.parameters,
23	this.varArgParameters = const [],
24	});
25
26	String _getCacheKeyString(	2✔
27	bool writeArgumentNames, String Function(Type) typeToString) {
28	final sb = StringBuffer();	2✔
29
30	// Write return Type.
31	sb.write(typeToString(returnType));	6✔
32
33	// Write Function.
34	sb.write(' Function(');	2✔
35	sb.write(parameters.map<String>((p) {	8✔
36	return '${typeToString(p.type)} ${writeArgumentNames ? p.name : ""}';	6✔
37	}).join(', '));	2✔
38	sb.write(')');	2✔
39
40	return sb.toString();	2✔
41	}
42
43	@override	28✔
44	String getCType(Writer w, {bool writeArgumentNames = true}) {
45	final sb = StringBuffer();	28✔
46
47	// Write return Type.
48	sb.write(returnType.getCType(w));	84✔
49
50	// Write Function.
51	sb.write(' Function(');	28✔
52	sb.write((parameters).map<String>((p) {	108✔
53	return '${p.type.getCType(w)} ${writeArgumentNames ? p.name : ""}';	82✔
54	}).join(', '));	28✔
55	if (varArgParameters.isNotEmpty) {	56✔
56	sb.write(", ${w.ffiLibraryPrefix}.VarArgs<(");	3✔
57	sb.write((varArgParameters).map<String>((p) {	4✔
58	return '${p.type.getCType(w)} ${writeArgumentNames ? p.name : ""}';	3✔
59	}).join(', '));	1✔
60	sb.write(",)>");	1✔
61	}
62	sb.write(')');	28✔
63
64	return sb.toString();	28✔
65	}
66
67	@override	27✔
68	String getFfiDartType(Writer w, {bool writeArgumentNames = true}) {
69	final sb = StringBuffer();	27✔
70
71	// Write return Type.
72	sb.write(returnType.getFfiDartType(w));	81✔
73
74	// Write Function.
75	sb.write(' Function(');	27✔
76	sb.write(dartTypeParameters.map<String>((p) {	104✔
77	return '${p.type.getFfiDartType(w)} ${writeArgumentNames ? p.name : ""}';	72✔
78	}).join(', '));	27✔
79	sb.write(')');	27✔
80
81	return sb.toString();	27✔
82	}
83
84	@override	×
85	bool get sameFfiDartAndCType =>
86	returnType.sameFfiDartAndCType &&	×
87	parameters.every((p) => p.type.sameFfiDartAndCType) &&	×
88	varArgParameters.every((p) => p.type.sameFfiDartAndCType);	×
89
90	@override	×
91	bool get sameDartAndCType =>
92	returnType.sameDartAndCType &&	×
93	parameters.every((p) => p.type.sameDartAndCType) &&	×
94	varArgParameters.every((p) => p.type.sameDartAndCType);	×
95
96	@override	2✔
97	String toString() => _getCacheKeyString(false, (Type t) => t.toString());	6✔
98
99	@override	2✔
100	String cacheKey() => _getCacheKeyString(false, (Type t) => t.cacheKey());	6✔
101
102	@override	30✔
103	void addDependencies(Set<Binding> dependencies) {
104	returnType.addDependencies(dependencies);	60✔
105	for (final p in parameters) {	55✔
106	p.type.addDependencies(dependencies);	50✔
107	}
108	}
109
110	void addParameterNames(List<String> names) {	8✔
111	if (names.length != parameters.length) {	32✔
112	return;
113	}
114	final paramNamer = UniqueNamer({});	7✔
115	for (int i = 0; i < parameters.length; i++) {	27✔
116	final finalName = paramNamer.makeUnique(names[i]);	12✔
117	parameters[i] = Parameter(	18✔
118	type: parameters[i].type,	18✔
119	originalName: names[i],	6✔
120	name: finalName,
121	);
122	}
123	}
124	}
125
126	/// Represents a NativeFunction<Function>.
127	class NativeFunc extends Type {
128	// Either a FunctionType or a Typealias of a FunctionType.
129	final Type _type;
130
131	NativeFunc(this._type) {	11✔
132	assert(_type is FunctionType \|\| _type is Typealias);	34✔
133	}
134
135	FunctionType get type {	7✔
136	if (_type is Typealias) {	14✔
137	return _type.typealiasType as FunctionType;	2✔
138	}
139	return _type as FunctionType;	7✔
140	}
141
142	@override	11✔
143	void addDependencies(Set<Binding> dependencies) {
144	_type.addDependencies(dependencies);	22✔
145	}
146
147	@override	11✔
148	String getCType(Writer w) =>
149	'${w.ffiLibraryPrefix}.NativeFunction<${_type.getCType(w)}>';	44✔
150
151	@override	2✔
152	String getFfiDartType(Writer w) => getCType(w);	2✔
153
154	@override	×
155	bool get sameFfiDartAndCType => true;
156
157	@override	2✔
158	String toString() => 'NativeFunction<${_type.toString()}>';	6✔
159
160	@override	2✔
161	String cacheKey() => 'NatFn(${_type.cacheKey()})';	6✔
162	}

dart-lang / ffigen / 6470767942

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