blob: d03a8150a0ddbe9f928c28826078d4b3b2467f51 [file] [log] [blame]
// Copyright (c) 2019, 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:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/ast/visitor.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/error/listener.dart';
import 'package:analyzer/src/dart/ast/extensions.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type_system.dart';
import 'package:analyzer/src/dart/error/ffi_code.dart';
/// A visitor used to find problems with the way the `dart:ffi` APIs are being
/// used. See 'pkg/vm/lib/transformations/ffi_checks.md' for the specification
/// of the desired hints.
class FfiVerifier extends RecursiveAstVisitor<void> {
static const _allocatorClassName = 'Allocator';
static const _allocateExtensionMethodName = 'call';
static const _allocatorExtensionName = 'AllocatorAlloc';
static const _arrayClassName = 'Array';
static const _dartFfiLibraryName = 'dart.ffi';
static const _isLeafParamName = 'isLeaf';
static const _opaqueClassName = 'Opaque';
static const List<String> _primitiveIntegerNativeTypes = [
'Int8',
'Int16',
'Int32',
'Int64',
'Uint8',
'Uint16',
'Uint32',
'Uint64',
'IntPtr'
];
static const List<String> _primitiveDoubleNativeTypes = [
'Float',
'Double',
];
static const _structClassName = 'Struct';
static const _unionClassName = 'Union';
/// The type system used to check types.
final TypeSystemImpl typeSystem;
/// The error reporter used to report errors.
final ErrorReporter _errorReporter;
/// A flag indicating whether we are currently visiting inside a subclass of
/// `Struct`.
bool inCompound = false;
/// Subclass of `Struct` or `Union` we are currently visiting, or `null`.
ClassDeclaration? compound;
/// Initialize a newly created verifier.
FfiVerifier(this.typeSystem, this._errorReporter);
@override
void visitClassDeclaration(ClassDeclaration node) {
inCompound = false;
compound = null;
// Only the Allocator, Opaque and Struct class may be extended.
var extendsClause = node.extendsClause;
if (extendsClause != null) {
final TypeName superclass = extendsClause.superclass;
final ffiClass = superclass.ffiClass;
if (ffiClass != null) {
final className = ffiClass.name;
if (className == _structClassName || className == _unionClassName) {
inCompound = true;
compound = node;
if (node.declaredElement!.isEmptyStruct) {
_errorReporter
.reportErrorForNode(FfiCode.EMPTY_STRUCT, node, [node.name]);
}
if (className == _structClassName) {
_validatePackedAnnotation(node.metadata);
}
} else if (className != _allocatorClassName &&
className != _opaqueClassName) {
_errorReporter.reportErrorForNode(
FfiCode.SUBTYPE_OF_FFI_CLASS_IN_EXTENDS,
superclass.name,
[node.name.name, superclass.name.name]);
}
} else if (superclass.isCompoundSubtype) {
_errorReporter.reportErrorForNode(
FfiCode.SUBTYPE_OF_STRUCT_CLASS_IN_EXTENDS,
superclass,
[node.name.name, superclass.name.name]);
}
}
// No classes from the FFI may be explicitly implemented.
void checkSupertype(TypeName typename, FfiCode subtypeOfFfiCode,
FfiCode subtypeOfStructCode) {
final superName = typename.name.staticElement?.name;
if (superName == _allocatorClassName) {
return;
}
if (typename.ffiClass != null) {
_errorReporter.reportErrorForNode(
subtypeOfFfiCode, typename, [node.name, typename.name]);
} else if (typename.isCompoundSubtype) {
_errorReporter.reportErrorForNode(
subtypeOfStructCode, typename, [node.name, typename.name]);
}
}
var implementsClause = node.implementsClause;
if (implementsClause != null) {
for (TypeName type in implementsClause.interfaces) {
checkSupertype(type, FfiCode.SUBTYPE_OF_FFI_CLASS_IN_IMPLEMENTS,
FfiCode.SUBTYPE_OF_STRUCT_CLASS_IN_IMPLEMENTS);
}
}
var withClause = node.withClause;
if (withClause != null) {
for (TypeName type in withClause.mixinTypes) {
checkSupertype(type, FfiCode.SUBTYPE_OF_FFI_CLASS_IN_WITH,
FfiCode.SUBTYPE_OF_STRUCT_CLASS_IN_WITH);
}
}
if (inCompound && node.declaredElement!.typeParameters.isNotEmpty) {
_errorReporter.reportErrorForNode(
FfiCode.GENERIC_STRUCT_SUBCLASS, node.name, [node.name]);
}
super.visitClassDeclaration(node);
}
@override
void visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
if (inCompound) {
_errorReporter.reportErrorForNode(
FfiCode.FIELD_INITIALIZER_IN_STRUCT, node);
}
super.visitConstructorFieldInitializer(node);
}
@override
void visitFieldDeclaration(FieldDeclaration node) {
if (inCompound) {
_validateFieldsInCompound(node);
}
super.visitFieldDeclaration(node);
}
@override
void visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
var element = node.staticElement;
if (element is MethodElement) {
var enclosingElement = element.enclosingElement;
if (enclosingElement.isAllocatorExtension &&
element.name == _allocateExtensionMethodName) {
_validateAllocate(node);
}
}
super.visitFunctionExpressionInvocation(node);
}
@override
void visitIndexExpression(IndexExpression node) {
var element = node.staticElement;
if (element is MethodElement) {
var enclosingElement = element.enclosingElement;
if (enclosingElement.isNativeStructPointerExtension ||
enclosingElement.isNativeStructArrayExtension) {
if (element.name == '[]') {
_validateRefIndexed(node);
}
}
}
}
@override
void visitMethodInvocation(MethodInvocation node) {
var element = node.methodName.staticElement;
if (element is MethodElement) {
Element enclosingElement = element.enclosingElement;
if (enclosingElement.isPointer) {
if (element.name == 'fromFunction') {
_validateFromFunction(node, element);
} else if (element.name == 'elementAt') {
_validateElementAt(node);
}
} else if (enclosingElement.isNativeFunctionPointerExtension) {
if (element.name == 'asFunction') {
_validateAsFunction(node, element);
}
} else if (enclosingElement.isDynamicLibraryExtension) {
if (element.name == 'lookupFunction') {
_validateLookupFunction(node);
}
}
} else if (element is FunctionElement) {
var enclosingElement = element.enclosingElement;
if (enclosingElement is CompilationUnitElement) {
if (element.library.name == 'dart.ffi') {
if (element.name == 'sizeOf') {
_validateSizeOf(node);
}
}
}
}
super.visitMethodInvocation(node);
}
@override
void visitPrefixedIdentifier(PrefixedIdentifier node) {
var element = node.staticElement;
if (element != null) {
var enclosingElement = element.enclosingElement;
if (enclosingElement.isNativeStructPointerExtension) {
if (element.name == 'ref') {
_validateRefPrefixedIdentifier(node);
}
}
}
super.visitPrefixedIdentifier(node);
}
@override
void visitPropertyAccess(PropertyAccess node) {
var element = node.propertyName.staticElement;
if (element != null) {
var enclosingElement = element.enclosingElement;
if (enclosingElement.isNativeStructPointerExtension) {
if (element.name == 'ref') {
_validateRefPropertyAccess(node);
}
}
}
super.visitPropertyAccess(node);
}
/// Returns `true` if [nativeType] is a C type that has a size.
bool _isSized(DartType nativeType) {
switch (_primitiveNativeType(nativeType)) {
case _PrimitiveDartType.double:
return true;
case _PrimitiveDartType.int:
return true;
case _PrimitiveDartType.void_:
return false;
case _PrimitiveDartType.handle:
return false;
case _PrimitiveDartType.none:
break;
}
if (nativeType.isCompoundSubtype) {
return true;
}
if (nativeType.isPointer) {
return true;
}
if (nativeType.isArray) {
return true;
}
return false;
}
/// Validates that the given type is a valid dart:ffi native function
/// signature.
bool _isValidFfiNativeFunctionType(DartType nativeType) {
if (nativeType is FunctionType && !nativeType.isDartCoreFunction) {
if (nativeType.namedParameterTypes.isNotEmpty ||
nativeType.optionalParameterTypes.isNotEmpty) {
return false;
}
if (!_isValidFfiNativeType(nativeType.returnType,
allowVoid: true, allowEmptyStruct: false, allowHandle: true)) {
return false;
}
for (final DartType typeArg in nativeType.normalParameterTypes) {
if (!_isValidFfiNativeType(typeArg,
allowVoid: false, allowEmptyStruct: false, allowHandle: true)) {
return false;
}
}
return true;
}
return false;
}
/// Validates that the given [nativeType] is a valid dart:ffi native type.
bool _isValidFfiNativeType(DartType? nativeType,
{bool allowVoid = false,
bool allowEmptyStruct = false,
bool allowArray = false,
bool allowHandle = false}) {
if (nativeType is InterfaceType) {
final primitiveType = _primitiveNativeType(nativeType);
switch (primitiveType) {
case _PrimitiveDartType.void_:
return allowVoid;
case _PrimitiveDartType.handle:
return allowHandle;
case _PrimitiveDartType.double:
case _PrimitiveDartType.int:
return true;
case _PrimitiveDartType.none:
// These are the cases below.
break;
}
if (nativeType.isNativeFunction) {
return _isValidFfiNativeFunctionType(nativeType.typeArguments.single);
}
if (nativeType.isPointer) {
final nativeArgumentType = nativeType.typeArguments.single;
return _isValidFfiNativeType(nativeArgumentType,
allowVoid: true, allowEmptyStruct: true, allowHandle: true) ||
nativeArgumentType.isCompoundSubtype ||
nativeArgumentType.isNativeType;
}
if (nativeType.isCompoundSubtype) {
if (!allowEmptyStruct) {
if (nativeType.element.isEmptyStruct) {
// TODO(dartbug.com/36780): This results in an error message not
// mentioning empty structs at all.
return false;
}
}
return true;
}
if (nativeType.isOpaqueSubtype) {
return true;
}
if (allowArray && nativeType.isArray) {
return _isValidFfiNativeType(nativeType.typeArguments.single,
allowVoid: false, allowEmptyStruct: false);
}
} else if (nativeType is FunctionType) {
return _isValidFfiNativeFunctionType(nativeType);
}
return false;
}
// Get the const bool value of `expr` if it exists.
// Return null if it isn't a const bool.
bool? _maybeGetBoolConstValue(Expression expr) {
if (expr is BooleanLiteral) {
return expr.value;
} else if (expr is Identifier) {
final staticElm = expr.staticElement;
if (staticElm is ConstVariableElement) {
return staticElm.computeConstantValue()?.toBoolValue();
}
if (staticElm is PropertyAccessorElementImpl) {
final v = staticElm.variable;
if (v is ConstVariableElement) {
return v.computeConstantValue()?.toBoolValue();
}
}
}
return null;
}
_PrimitiveDartType _primitiveNativeType(DartType nativeType) {
if (nativeType is InterfaceType) {
final element = nativeType.element;
if (element.isFfiClass) {
final String name = element.name;
if (_primitiveIntegerNativeTypes.contains(name)) {
return _PrimitiveDartType.int;
}
if (_primitiveDoubleNativeTypes.contains(name)) {
return _PrimitiveDartType.double;
}
if (name == 'Void') {
return _PrimitiveDartType.void_;
}
if (name == 'Handle') {
return _PrimitiveDartType.handle;
}
}
}
return _PrimitiveDartType.none;
}
/// Return an indication of the Dart type associated with the [annotation].
_PrimitiveDartType _typeForAnnotation(Annotation annotation) {
var element = annotation.element;
if (element is ConstructorElement) {
String name = element.enclosingElement.name;
if (_primitiveIntegerNativeTypes.contains(name)) {
return _PrimitiveDartType.int;
} else if (_primitiveDoubleNativeTypes.contains(name)) {
return _PrimitiveDartType.double;
}
}
return _PrimitiveDartType.none;
}
void _validateAllocate(FunctionExpressionInvocation node) {
final typeArgumentTypes = node.typeArgumentTypes;
if (typeArgumentTypes == null || typeArgumentTypes.length != 1) {
return;
}
final DartType dartType = typeArgumentTypes[0];
if (!_isValidFfiNativeType(dartType,
allowVoid: true, allowEmptyStruct: true)) {
final AstNode errorNode = node;
_errorReporter.reportErrorForNode(
FfiCode.NON_CONSTANT_TYPE_ARGUMENT,
errorNode,
['$_allocatorExtensionName.$_allocateExtensionMethodName']);
}
}
/// Validate that the [annotations] include exactly one annotation that
/// satisfies the [requiredTypes]. If an error is produced that cannot be
/// associated with an annotation, associate it with the [errorNode].
void _validateAnnotations(AstNode errorNode, NodeList<Annotation> annotations,
_PrimitiveDartType requiredType) {
bool requiredFound = false;
List<Annotation> extraAnnotations = [];
for (Annotation annotation in annotations) {
if (annotation.element.ffiClass != null) {
if (requiredFound) {
extraAnnotations.add(annotation);
} else {
_PrimitiveDartType foundType = _typeForAnnotation(annotation);
if (foundType == requiredType) {
requiredFound = true;
} else {
extraAnnotations.add(annotation);
}
}
}
}
if (extraAnnotations.isNotEmpty) {
if (!requiredFound) {
Annotation invalidAnnotation = extraAnnotations.removeAt(0);
_errorReporter.reportErrorForNode(
FfiCode.MISMATCHED_ANNOTATION_ON_STRUCT_FIELD, invalidAnnotation);
}
for (Annotation extraAnnotation in extraAnnotations) {
_errorReporter.reportErrorForNode(
FfiCode.EXTRA_ANNOTATION_ON_STRUCT_FIELD, extraAnnotation);
}
} else if (!requiredFound) {
_errorReporter.reportErrorForNode(
FfiCode.MISSING_ANNOTATION_ON_STRUCT_FIELD, errorNode);
}
}
/// Validate the invocation of the instance method
/// `Pointer<T>.asFunction<F>()`.
void _validateAsFunction(MethodInvocation node, MethodElement element) {
var typeArguments = node.typeArguments?.arguments;
if (typeArguments != null && typeArguments.length == 1) {
if (_validateTypeArgument(typeArguments[0], 'asFunction')) {
return;
}
}
var target = node.realTarget!;
var targetType = target.staticType;
if (targetType is InterfaceType && targetType.isPointer) {
final DartType T = targetType.typeArguments[0];
if (!T.isNativeFunction ||
!_isValidFfiNativeFunctionType(
(T as InterfaceType).typeArguments.single)) {
final AstNode errorNode =
typeArguments != null ? typeArguments[0] : node;
_errorReporter.reportErrorForNode(
FfiCode.NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER,
errorNode,
[T]);
return;
}
final DartType TPrime = T.typeArguments[0];
final DartType F = node.typeArgumentTypes![0];
if (!_validateCompatibleFunctionTypes(F, TPrime)) {
_errorReporter.reportErrorForNode(
FfiCode.MUST_BE_A_SUBTYPE, node, [TPrime, F, 'asFunction']);
}
_validateFfiLeafCallUsesNoHandles(node, TPrime, node);
}
_validateIsLeafIsConst(node);
}
/// Validates that the given [nativeType] is, when native types are converted
/// to their Dart equivalent, a subtype of [dartType].
bool _validateCompatibleFunctionTypes(
DartType dartType, DartType nativeType) {
// We require both to be valid function types.
if (dartType is! FunctionType ||
dartType.isDartCoreFunction ||
nativeType is! FunctionType ||
nativeType.isDartCoreFunction) {
return false;
}
// We disallow any optional parameters.
final int parameterCount = dartType.normalParameterTypes.length;
if (parameterCount != nativeType.normalParameterTypes.length) {
return false;
}
// We disallow generic function types.
if (dartType.typeFormals.isNotEmpty || nativeType.typeFormals.isNotEmpty) {
return false;
}
if (dartType.namedParameterTypes.isNotEmpty ||
dartType.optionalParameterTypes.isNotEmpty ||
nativeType.namedParameterTypes.isNotEmpty ||
nativeType.optionalParameterTypes.isNotEmpty) {
return false;
}
// Validate that the return types are compatible.
if (!_validateCompatibleNativeType(
dartType.returnType, nativeType.returnType, false)) {
return false;
}
// Validate that the parameter types are compatible.
for (int i = 0; i < parameterCount; ++i) {
if (!_validateCompatibleNativeType(dartType.normalParameterTypes[i],
nativeType.normalParameterTypes[i], true)) {
return false;
}
}
// Signatures have same number of parameters and the types match.
return true;
}
/// Validates that, if we convert [nativeType] to it's corresponding
/// [dartType] the latter is a subtype of the former if
/// [checkCovariance].
bool _validateCompatibleNativeType(
DartType dartType, DartType nativeType, bool checkCovariance) {
final nativeReturnType = _primitiveNativeType(nativeType);
if (nativeReturnType == _PrimitiveDartType.int) {
return dartType.isDartCoreInt;
} else if (nativeReturnType == _PrimitiveDartType.double) {
return dartType.isDartCoreDouble;
} else if (nativeReturnType == _PrimitiveDartType.void_) {
return dartType.isVoid;
} else if (nativeReturnType == _PrimitiveDartType.handle) {
InterfaceType objectType = typeSystem.objectStar;
return checkCovariance
? /* everything is subtype of objectStar */ true
: typeSystem.isSubtypeOf(objectType, dartType);
} else if (dartType is InterfaceType && nativeType is InterfaceType) {
return checkCovariance
? typeSystem.isSubtypeOf(dartType, nativeType)
: typeSystem.isSubtypeOf(nativeType, dartType);
} else {
// If the [nativeType] is not a primitive int/double type then it has to
// be a Pointer type atm.
return false;
}
}
void _validateElementAt(MethodInvocation node) {
var targetType = node.realTarget?.staticType;
if (targetType is InterfaceType && targetType.isPointer) {
final DartType T = targetType.typeArguments[0];
if (!_isValidFfiNativeType(T, allowVoid: true, allowEmptyStruct: true)) {
final AstNode errorNode = node;
_errorReporter.reportErrorForNode(
FfiCode.NON_CONSTANT_TYPE_ARGUMENT, errorNode, ['elementAt']);
}
}
}
void _validateFfiLeafCallUsesNoHandles(
MethodInvocation node, DartType nativeType, AstNode errorNode) {
final args = node.argumentList.arguments;
if (args.isNotEmpty) {
for (final arg in args) {
if (arg is NamedExpression) {
if (arg.element?.name == _isLeafParamName) {
// Handles are ok for regular (non-leaf) calls. Check `isLeaf:true`.
final bool? isLeaf = _maybeGetBoolConstValue(arg.expression);
if (isLeaf != null && isLeaf) {
if (nativeType is FunctionType) {
if (_primitiveNativeType(nativeType.returnType) ==
_PrimitiveDartType.handle) {
_errorReporter.reportErrorForNode(
FfiCode.LEAF_CALL_MUST_NOT_RETURN_HANDLE, errorNode);
}
for (final param in nativeType.normalParameterTypes) {
if (_primitiveNativeType(param) ==
_PrimitiveDartType.handle) {
_errorReporter.reportErrorForNode(
FfiCode.LEAF_CALL_MUST_NOT_TAKE_HANDLE, errorNode);
}
}
}
}
}
}
}
}
}
/// Validate that the fields declared by the given [node] meet the
/// requirements for fields within a struct or union class.
void _validateFieldsInCompound(FieldDeclaration node) {
if (node.isStatic) {
return;
}
VariableDeclarationList fields = node.fields;
NodeList<Annotation> annotations = node.metadata;
var fieldType = fields.type;
if (fieldType == null) {
_errorReporter.reportErrorForNode(
FfiCode.MISSING_FIELD_TYPE_IN_STRUCT, fields.variables[0].name);
} else {
DartType declaredType = fieldType.typeOrThrow;
if (declaredType.isDartCoreInt) {
_validateAnnotations(fieldType, annotations, _PrimitiveDartType.int);
} else if (declaredType.isDartCoreDouble) {
_validateAnnotations(fieldType, annotations, _PrimitiveDartType.double);
} else if (declaredType.isPointer) {
_validateNoAnnotations(annotations);
} else if (declaredType.isArray) {
final typeArg = (declaredType as InterfaceType).typeArguments.single;
if (!_isSized(typeArg)) {
_errorReporter.reportErrorForNode(FfiCode.NON_SIZED_TYPE_ARGUMENT,
fieldType, [_arrayClassName, typeArg.toString()]);
}
final arrayDimensions = declaredType.arrayDimensions;
_validateSizeOfAnnotation(fieldType, annotations, arrayDimensions);
final arrayElement = declaredType.arrayElementType;
if (arrayElement.isCompoundSubtype) {
final elementClass = (arrayElement as InterfaceType).element;
_validatePackingNesting(compound!.declaredElement!, elementClass,
errorNode: fieldType);
}
} else if (declaredType.isCompoundSubtype) {
final clazz = (declaredType as InterfaceType).element;
if (clazz.isEmptyStruct) {
_errorReporter
.reportErrorForNode(FfiCode.EMPTY_STRUCT, node, [clazz.name]);
}
_validatePackingNesting(compound!.declaredElement!, clazz,
errorNode: fieldType);
} else {
_errorReporter.reportErrorForNode(FfiCode.INVALID_FIELD_TYPE_IN_STRUCT,
fieldType, [fieldType.toSource()]);
}
}
for (VariableDeclaration field in fields.variables) {
if (field.initializer != null) {
_errorReporter.reportErrorForNode(
FfiCode.FIELD_IN_STRUCT_WITH_INITIALIZER, field.name);
}
}
}
/// Validate the invocation of the static method
/// `Pointer<T>.fromFunction(f, e)`.
void _validateFromFunction(MethodInvocation node, MethodElement element) {
final int argCount = node.argumentList.arguments.length;
if (argCount < 1 || argCount > 2) {
// There are other diagnostics reported against the invocation and the
// diagnostics generated below might be inaccurate, so don't report them.
return;
}
final DartType T = node.typeArgumentTypes![0];
if (!_isValidFfiNativeFunctionType(T)) {
_errorReporter.reportErrorForNode(
FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE, node, [T, 'fromFunction']);
return;
}
Expression f = node.argumentList.arguments[0];
DartType FT = f.typeOrThrow;
if (!_validateCompatibleFunctionTypes(FT, T)) {
_errorReporter.reportErrorForNode(
FfiCode.MUST_BE_A_SUBTYPE, f, [f.staticType, T, 'fromFunction']);
return;
}
// TODO(brianwilkerson) Validate that `f` is a top-level function.
final DartType R = (T as FunctionType).returnType;
if ((FT as FunctionType).returnType.isVoid ||
R.isPointer ||
R.isHandle ||
R.isCompoundSubtype) {
if (argCount != 1) {
_errorReporter.reportErrorForNode(
FfiCode.INVALID_EXCEPTION_VALUE, node.argumentList.arguments[1]);
}
} else if (argCount != 2) {
_errorReporter.reportErrorForNode(
FfiCode.MISSING_EXCEPTION_VALUE, node.methodName);
} else {
Expression e = node.argumentList.arguments[1];
// TODO(brianwilkerson) Validate that `e` is a constant expression.
if (!_validateCompatibleNativeType(e.typeOrThrow, R, true)) {
_errorReporter.reportErrorForNode(
FfiCode.MUST_BE_A_SUBTYPE, e, [e.staticType, R, 'fromFunction']);
}
}
}
void _validateIsLeafIsConst(MethodInvocation node) {
// Ensure `isLeaf` is const as we need the value at compile time to know
// which trampoline to generate.
final args = node.argumentList.arguments;
if (args.isNotEmpty) {
for (final arg in args) {
if (arg is NamedExpression) {
if (arg.element?.name == _isLeafParamName) {
if (_maybeGetBoolConstValue(arg.expression) == null) {
final AstNode errorNode = node;
_errorReporter.reportErrorForNode(
FfiCode.ARGUMENT_MUST_BE_A_CONSTANT,
errorNode,
[_isLeafParamName]);
}
}
}
}
}
}
/// Validate the invocation of the instance method
/// `DynamicLibrary.lookupFunction<S, F>()`.
void _validateLookupFunction(MethodInvocation node) {
final typeArguments = node.typeArguments?.arguments;
if (typeArguments?.length != 2) {
// There are other diagnostics reported against the invocation and the
// diagnostics generated below might be inaccurate, so don't report them.
return;
}
final List<DartType> argTypes = node.typeArgumentTypes!;
final DartType S = argTypes[0];
final DartType F = argTypes[1];
if (!_isValidFfiNativeFunctionType(S)) {
final AstNode errorNode = typeArguments![0];
_errorReporter.reportErrorForNode(FfiCode.MUST_BE_A_NATIVE_FUNCTION_TYPE,
errorNode, [S, 'lookupFunction']);
return;
}
if (!_validateCompatibleFunctionTypes(F, S)) {
final AstNode errorNode = typeArguments![1];
_errorReporter.reportErrorForNode(
FfiCode.MUST_BE_A_SUBTYPE, errorNode, [S, F, 'lookupFunction']);
}
_validateIsLeafIsConst(node);
_validateFfiLeafCallUsesNoHandles(node, S, typeArguments![0]);
}
/// Validate that none of the [annotations] are from `dart:ffi`.
void _validateNoAnnotations(NodeList<Annotation> annotations) {
for (Annotation annotation in annotations) {
if (annotation.element.ffiClass != null) {
_errorReporter.reportErrorForNode(
FfiCode.ANNOTATION_ON_POINTER_FIELD, annotation);
}
}
}
/// Validate that the [annotations] include at most one packed annotation.
void _validatePackedAnnotation(NodeList<Annotation> annotations) {
final ffiPackedAnnotations =
annotations.where((annotation) => annotation.isPacked).toList();
if (ffiPackedAnnotations.isEmpty) {
return;
}
if (ffiPackedAnnotations.length > 1) {
final extraAnnotations = ffiPackedAnnotations.skip(1);
for (final annotation in extraAnnotations) {
_errorReporter.reportErrorForNode(
FfiCode.PACKED_ANNOTATION, annotation);
}
}
// Check number of dimensions.
final annotation = ffiPackedAnnotations.first;
final value = annotation.elementAnnotation?.packedMemberAlignment;
if (![1, 2, 4, 8, 16].contains(value)) {
_errorReporter.reportErrorForNode(
FfiCode.PACKED_ANNOTATION_ALIGNMENT, annotation);
}
}
void _validatePackingNesting(ClassElement outer, ClassElement nested,
{required TypeAnnotation errorNode}) {
final outerPacking = outer.structPacking;
if (outerPacking == null) {
// No packing for outer class, so we're done.
return;
}
bool error = false;
final nestedPacking = nested.structPacking;
if (nestedPacking == null) {
// The outer struct packs, but the nested struct does not.
error = true;
} else if (outerPacking < nestedPacking) {
// The outer struct packs tighter than the nested struct.
error = true;
}
if (error) {
_errorReporter.reportErrorForNode(FfiCode.PACKED_NESTING_NON_PACKED,
errorNode, [nested.name, outer.name]);
}
}
void _validateRefIndexed(IndexExpression node) {
var targetType = node.realTarget.staticType;
if (!_isValidFfiNativeType(targetType,
allowVoid: false, allowEmptyStruct: true, allowArray: true)) {
final AstNode errorNode = node;
_errorReporter.reportErrorForNode(
FfiCode.NON_CONSTANT_TYPE_ARGUMENT, errorNode, ['[]']);
}
}
/// Validate the invocation of the extension method
/// `Pointer<T extends Struct>.ref`.
void _validateRefPrefixedIdentifier(PrefixedIdentifier node) {
var targetType = node.prefix.typeOrThrow;
if (!_isValidFfiNativeType(targetType,
allowVoid: false, allowEmptyStruct: true)) {
final AstNode errorNode = node;
_errorReporter.reportErrorForNode(
FfiCode.NON_CONSTANT_TYPE_ARGUMENT, errorNode, ['ref']);
}
}
void _validateRefPropertyAccess(PropertyAccess node) {
var targetType = node.realTarget.staticType;
if (!_isValidFfiNativeType(targetType,
allowVoid: false, allowEmptyStruct: true)) {
final AstNode errorNode = node;
_errorReporter.reportErrorForNode(
FfiCode.NON_CONSTANT_TYPE_ARGUMENT, errorNode, ['ref']);
}
}
void _validateSizeOf(MethodInvocation node) {
final typeArgumentTypes = node.typeArgumentTypes;
if (typeArgumentTypes == null || typeArgumentTypes.length != 1) {
return;
}
final DartType T = typeArgumentTypes[0];
if (!_isValidFfiNativeType(T, allowVoid: true, allowEmptyStruct: true)) {
final AstNode errorNode = node;
_errorReporter.reportErrorForNode(
FfiCode.NON_CONSTANT_TYPE_ARGUMENT, errorNode, ['sizeOf']);
}
}
/// Validate that the [annotations] include exactly one size annotation. If
/// an error is produced that cannot be associated with an annotation,
/// associate it with the [errorNode].
void _validateSizeOfAnnotation(AstNode errorNode,
NodeList<Annotation> annotations, int arrayDimensions) {
final ffiSizeAnnotations =
annotations.where((annotation) => annotation.isArray).toList();
if (ffiSizeAnnotations.isEmpty) {
_errorReporter.reportErrorForNode(
FfiCode.MISSING_SIZE_ANNOTATION_CARRAY, errorNode);
return;
}
if (ffiSizeAnnotations.length > 1) {
final extraAnnotations = ffiSizeAnnotations.skip(1);
for (final annotation in extraAnnotations) {
_errorReporter.reportErrorForNode(
FfiCode.EXTRA_SIZE_ANNOTATION_CARRAY, annotation);
}
}
// Check number of dimensions.
final annotation = ffiSizeAnnotations.first;
final dimensions = annotation.elementAnnotation?.arraySizeDimensions ?? [];
final annotationDimensions = dimensions.length;
if (annotationDimensions != arrayDimensions) {
_errorReporter.reportErrorForNode(
FfiCode.SIZE_ANNOTATION_DIMENSIONS, annotation);
}
// Check dimensions is positive
for (int dimension in dimensions) {
if (dimension <= 0) {
_errorReporter.reportErrorForNode(
FfiCode.NON_POSITIVE_ARRAY_DIMENSION, annotation);
}
}
}
/// Validate that the given [typeArgument] has a constant value. Return `true`
/// if a diagnostic was produced because it isn't constant.
bool _validateTypeArgument(TypeAnnotation typeArgument, String functionName) {
if (typeArgument.type is TypeParameterType) {
_errorReporter.reportErrorForNode(
FfiCode.NON_CONSTANT_TYPE_ARGUMENT, typeArgument, [functionName]);
return true;
}
return false;
}
}
enum _PrimitiveDartType {
double,
int,
void_,
handle,
none,
}
extension on Annotation {
bool get isArray {
final element = this.element;
return element is ConstructorElement &&
element.ffiClass != null &&
element.enclosingElement.name == 'Array';
}
bool get isPacked {
final element = this.element;
return element is ConstructorElement &&
element.ffiClass != null &&
element.enclosingElement.name == 'Packed';
}
}
extension on ElementAnnotation {
bool get isArray {
final element = this.element;
return element is ConstructorElement &&
element.ffiClass != null &&
element.enclosingElement.name == 'Array';
// Note: this is 'Array' instead of '_ArraySize' because it finds the
// forwarding factory instead of the forwarded constructor.
}
bool get isPacked {
final element = this.element;
return element is ConstructorElement &&
element.ffiClass != null &&
element.enclosingElement.name == 'Packed';
}
List<int> get arraySizeDimensions {
assert(isArray);
final value = computeConstantValue();
// Element of `@Array.multi([1, 2, 3])`.
final listField = value?.getField('dimensions');
if (listField != null) {
final listValues = listField
.toListValue()
?.map((dartValue) => dartValue.toIntValue())
.whereType<int>()
.toList();
if (listValues != null) {
return listValues;
}
}
// Element of `@Array(1, 2, 3)`.
const dimensionFieldNames = [
'dimension1',
'dimension2',
'dimension3',
'dimension4',
'dimension5',
];
var result = <int>[];
for (final dimensionFieldName in dimensionFieldNames) {
final dimensionValue = value?.getField(dimensionFieldName)?.toIntValue();
if (dimensionValue != null) {
result.add(dimensionValue);
}
}
return result;
}
int? get packedMemberAlignment {
assert(isPacked);
final value = computeConstantValue();
return value?.getField('memberAlignment')?.toIntValue();
}
}
extension on Element? {
/// Return `true` if this represents the extension `AllocatorAlloc`.
bool get isAllocatorExtension {
final element = this;
return element is ExtensionElement &&
element.name == FfiVerifier._allocatorExtensionName &&
element.isFfiExtension;
}
bool get isNativeFunctionPointerExtension {
final element = this;
return element is ExtensionElement &&
element.name == 'NativeFunctionPointer' &&
element.isFfiExtension;
}
bool get isNativeStructArrayExtension {
final element = this;
return element is ExtensionElement &&
element.name == 'StructArray' &&
element.isFfiExtension;
}
bool get isNativeStructPointerExtension {
final element = this;
return element is ExtensionElement &&
element.name == 'StructPointer' &&
element.isFfiExtension;
}
/// Return `true` if this represents the extension `DynamicLibraryExtension`.
bool get isDynamicLibraryExtension {
final element = this;
return element is ExtensionElement &&
element.name == 'DynamicLibraryExtension' &&
element.isFfiExtension;
}
/// Return `true` if this represents the class `Pointer`.
bool get isPointer {
final element = this;
return element is ClassElement &&
element.name == 'Pointer' &&
element.isFfiClass;
}
/// If this is a class element from `dart:ffi`, return it.
ClassElement? get ffiClass {
var element = this;
if (element is ConstructorElement) {
element = element.enclosingElement;
}
if (element is ClassElement && element.isFfiClass) {
return element;
}
return null;
}
}
extension on ClassElement {
bool get isEmptyStruct {
for (final field in fields) {
final declaredType = field.type;
if (declaredType.isDartCoreInt) {
return false;
} else if (declaredType.isDartCoreDouble) {
return false;
} else if (declaredType.isPointer) {
return false;
} else if (declaredType.isCompoundSubtype) {
return false;
} else if (declaredType.isArray) {
return false;
}
}
return true;
}
bool get isFfiClass {
return library.name == FfiVerifier._dartFfiLibraryName;
}
int? get structPacking {
final packedAnnotations =
metadata.where((annotation) => annotation.isPacked);
if (packedAnnotations.isEmpty) {
return null;
}
return packedAnnotations.first.packedMemberAlignment;
}
}
extension on ExtensionElement {
bool get isFfiExtension {
return library.name == FfiVerifier._dartFfiLibraryName;
}
}
extension on DartType {
/// Return `true` if this represents the class `Array`.
bool get isArray {
final self = this;
if (self is InterfaceType) {
final element = self.element;
return element.name == FfiVerifier._arrayClassName && element.isFfiClass;
}
return false;
}
int get arrayDimensions {
DartType iterator = this;
int dimensions = 0;
while (iterator is InterfaceType &&
iterator.element.name == FfiVerifier._arrayClassName &&
iterator.element.isFfiClass) {
dimensions++;
iterator = iterator.typeArguments.single;
}
return dimensions;
}
DartType get arrayElementType {
DartType iterator = this;
while (iterator is InterfaceType &&
iterator.element.name == FfiVerifier._arrayClassName &&
iterator.element.isFfiClass) {
iterator = iterator.typeArguments.single;
}
return iterator;
}
bool get isPointer {
final self = this;
return self is InterfaceType && self.element.isPointer;
}
bool get isHandle {
final self = this;
if (self is InterfaceType) {
final element = self.element;
return element.name == 'Handle' && element.isFfiClass;
}
return false;
}
/// Returns `true` iff this is a `ffi.NativeFunction<???>` type.
bool get isNativeFunction {
final self = this;
if (self is InterfaceType) {
final element = self.element;
return element.name == 'NativeFunction' && element.isFfiClass;
}
return false;
}
/// Returns `true` iff this is a `ffi.NativeType` type.
bool get isNativeType {
final self = this;
if (self is InterfaceType) {
final element = self.element;
return element.name == 'NativeType' && element.isFfiClass;
}
return false;
}
/// Returns `true` iff this is a opaque type, i.e. a subtype of `Opaque`.
bool get isOpaqueSubtype {
final self = this;
if (self is InterfaceType) {
final superType = self.element.supertype;
if (superType != null) {
final superClassElement = superType.element;
return superClassElement.name == FfiVerifier._opaqueClassName &&
superClassElement.isFfiClass;
}
}
return false;
}
bool get isCompound {
final self = this;
if (self is InterfaceType) {
final element = self.element;
final name = element.name;
return (name == FfiVerifier._structClassName ||
name == FfiVerifier._unionClassName) &&
element.isFfiClass;
}
return false;
}
/// Returns `true` if this is a struct type, i.e. a subtype of `Struct`.
bool get isCompoundSubtype {
final self = this;
if (self is InterfaceType) {
final superType = self.element.supertype;
if (superType != null) {
return superType.isCompound;
}
}
return false;
}
}
extension on TypeName {
/// If this is a name of class from `dart:ffi`, return it.
ClassElement? get ffiClass {
return name.staticElement.ffiClass;
}
/// Return `true` if this represents a subtype of `Struct` or `Union`.
bool get isCompoundSubtype {
var element = name.staticElement;
if (element is ClassElement) {
bool isCompound(InterfaceType? type) {
return type != null && type.isCompound;
}
return isCompound(element.supertype) ||
element.interfaces.any(isCompound) ||
element.mixins.any(isCompound);
}
return false;
}
}