| // Copyright (c) 2023, 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:_js_interop_checks/src/transformations/js_util_optimizer.dart' |
| show ExtensionIndex; |
| import 'package:kernel/ast.dart'; |
| import 'package:kernel/core_types.dart'; |
| import 'package:kernel/type_environment.dart'; |
| |
| enum AnnotationType { import, export, weakExport } |
| |
| /// A utility wrapper for [CoreTypes]. |
| class CoreTypesUtil { |
| final ExtensionIndex extensionIndex; |
| final CoreTypes coreTypes; |
| final Procedure allowInteropTarget; |
| final Procedure dartifyRawTarget; |
| final Procedure functionToJSTarget; |
| final Procedure functionToJSCaptureThisTarget; |
| final Procedure greaterThanOrEqualToTarget; |
| final Procedure inlineJSTarget; |
| final Procedure isDartFunctionWrappedTarget; |
| final Procedure jsifyRawTarget; |
| final Procedure jsObjectFromDartObjectTarget; |
| final Class jsValueClass; |
| final Procedure jsValueBoxTarget; |
| final Procedure jsValueUnboxTarget; |
| final Procedure numToIntTarget; |
| final Class wasmExternRefClass; |
| final Class wasmArrayClass; |
| final Class wasmArrayRefClass; |
| final Procedure wrapDartFunctionTarget; |
| final Procedure exportWasmFunctionTarget; |
| final Member wasmExternRefNullRef; |
| final Class wasmI32Class; |
| final Procedure wasmI32ToIntSigned; |
| final Procedure isDartNullTarget; |
| final Procedure throwArgumentNullErrorTarget; |
| |
| // Dart value to JS converters. |
| final Procedure toJSBoolean; |
| final Procedure jsifyInt; |
| final Procedure toJSNumber; |
| final Procedure jsifyNum; |
| final Procedure jsifyJSValue; |
| final Procedure jsifyString; |
| final Procedure jsifyJSInt8ArrayImpl; |
| final Procedure jsifyJSUint8ArrayImpl; |
| final Procedure jsifyJSUint8ClampedArrayImpl; |
| final Procedure jsifyJSInt16ArrayImpl; |
| final Procedure jsifyJSUint16ArrayImpl; |
| final Procedure jsifyJSInt32ArrayImpl; |
| final Procedure jsifyJSUint32ArrayImpl; |
| final Procedure jsifyJSFloat32ArrayImpl; |
| final Procedure jsifyJSFloat64ArrayImpl; |
| final Procedure jsInt8ArrayFromDartInt8List; |
| final Procedure jsUint8ArrayFromDartUint8List; |
| final Procedure jsUint8ClampedArrayFromDartUint8ClampedList; |
| final Procedure jsInt16ArrayFromDartInt16List; |
| final Procedure jsUint16ArrayFromDartUint16List; |
| final Procedure jsInt32ArrayFromDartInt32List; |
| final Procedure jsUint32ArrayFromDartUint32List; |
| final Procedure jsFloat32ArrayFromDartFloat32List; |
| final Procedure jsFloat64ArrayFromDartFloat64List; |
| final Procedure jsifyJSDataViewImpl; // JS ByteData |
| final Procedure jsifyByteData; // Wasm ByteData |
| final Procedure jsifyRawList; |
| final Procedure jsifyJSArrayBufferImpl; // JS ByteBuffer |
| final Procedure jsArrayBufferFromDartByteBuffer; // Wasm ByteBuffer |
| final Procedure jsifyFunction; |
| |
| // Classes used in type tests for the converters. |
| final Class jsInt8ArrayImplClass; |
| final Class jsUint8ArrayImplClass; |
| final Class jsUint8ClampedArrayImplClass; |
| final Class jsInt16ArrayImplClass; |
| final Class jsUint16ArrayImplClass; |
| final Class jsInt32ArrayImplClass; |
| final Class jsUint32ArrayImplClass; |
| final Class jsFloat32ArrayImplClass; |
| final Class jsFloat64ArrayImplClass; |
| final Class int8ListClass; |
| final Class uint8ListClass; |
| final Class uint8ClampedListClass; |
| final Class int16ListClass; |
| final Class uint16ListClass; |
| final Class int32ListClass; |
| final Class uint32ListClass; |
| final Class float32ListClass; |
| final Class float64ListClass; |
| final Class jsDataViewImplClass; |
| final Class byteDataClass; |
| final Class jsArrayBufferImplClass; |
| final Class byteBufferClass; |
| |
| // NB. We rely on iteration ordering being insertion order to handle subtypes |
| // before supertypes to convert as `int` and `double` before `num`. |
| late final Map<Class, Procedure> _jsifyMap = { |
| coreTypes.boolClass: toJSBoolean, |
| coreTypes.intClass: jsifyInt, |
| coreTypes.doubleClass: toJSNumber, |
| coreTypes.numClass: jsifyNum, |
| jsValueClass: jsifyJSValue, |
| coreTypes.stringClass: jsifyString, |
| jsInt8ArrayImplClass: jsifyJSInt8ArrayImpl, |
| jsUint8ArrayImplClass: jsifyJSUint8ArrayImpl, |
| jsUint8ClampedArrayImplClass: jsifyJSUint8ClampedArrayImpl, |
| jsInt16ArrayImplClass: jsifyJSInt16ArrayImpl, |
| jsUint16ArrayImplClass: jsifyJSUint16ArrayImpl, |
| jsInt32ArrayImplClass: jsifyJSInt32ArrayImpl, |
| jsUint32ArrayImplClass: jsifyJSUint32ArrayImpl, |
| jsFloat32ArrayImplClass: jsifyJSFloat32ArrayImpl, |
| jsFloat64ArrayImplClass: jsifyJSFloat64ArrayImpl, |
| int8ListClass: jsInt8ArrayFromDartInt8List, |
| uint8ListClass: jsUint8ArrayFromDartUint8List, |
| uint8ClampedListClass: jsUint8ClampedArrayFromDartUint8ClampedList, |
| int16ListClass: jsInt16ArrayFromDartInt16List, |
| uint16ListClass: jsUint16ArrayFromDartUint16List, |
| int32ListClass: jsInt32ArrayFromDartInt32List, |
| uint32ListClass: jsUint32ArrayFromDartUint32List, |
| float32ListClass: jsFloat32ArrayFromDartFloat32List, |
| float64ListClass: jsFloat64ArrayFromDartFloat64List, |
| jsDataViewImplClass: jsifyJSDataViewImpl, |
| byteDataClass: jsifyByteData, |
| coreTypes.listClass: jsifyRawList, |
| jsArrayBufferImplClass: jsifyJSArrayBufferImpl, |
| byteBufferClass: jsArrayBufferFromDartByteBuffer, |
| coreTypes.functionClass: jsifyFunction, |
| }; |
| |
| late final Map<Class, Procedure> _dartifyMap = { |
| coreTypes.boolClass: |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'toDartBool'), |
| coreTypes.intClass: |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'dartifyInt'), |
| coreTypes.doubleClass: |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'toDartNumber'), |
| coreTypes.numClass: |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'toDartNumber'), |
| coreTypes.stringClass: |
| coreTypes.index.getProcedure('dart:_string', 'JSStringImpl', 'fromRef'), |
| coreTypes.listClass: |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'toDartList'), |
| coreTypes.index.getClass('dart:typed_data', 'Int8List'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSInt8ArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'Uint8List'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSUint8ArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'Uint8ClampedList'): coreTypes |
| .index |
| .getProcedure('dart:_js_types', 'JSUint8ClampedArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'Int16List'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSInt16ArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'Uint16List'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSUint16ArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'Int32List'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSInt32ArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'Uint32List'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSUint32ArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'Float32List'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSFloat32ArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'Float64List'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSFloat64ArrayImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'ByteBuffer'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSArrayBufferImpl', 'fromRef'), |
| coreTypes.index.getClass('dart:typed_data', 'ByteData'): coreTypes.index |
| .getProcedure('dart:_js_types', 'JSDataViewImpl', 'fromRef'), |
| }; |
| |
| CoreTypesUtil(this.coreTypes, this.extensionIndex) |
| : allowInteropTarget = coreTypes.index |
| .getTopLevelProcedure('dart:js_util', 'allowInterop'), |
| dartifyRawTarget = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'dartifyRaw'), |
| functionToJSTarget = coreTypes.index.getTopLevelProcedure( |
| 'dart:js_interop', 'FunctionToJSExportedDartFunction|get#toJS'), |
| functionToJSCaptureThisTarget = coreTypes.index.getTopLevelProcedure( |
| 'dart:js_interop', |
| 'FunctionToJSExportedDartFunction|get#toJSCaptureThis'), |
| greaterThanOrEqualToTarget = |
| coreTypes.index.getProcedure('dart:core', 'num', '>='), |
| inlineJSTarget = |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'JS'), |
| isDartFunctionWrappedTarget = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', '_isDartFunctionWrapped'), |
| numToIntTarget = |
| coreTypes.index.getProcedure('dart:core', 'num', 'toInt'), |
| jsifyRawTarget = |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'jsifyRaw'), |
| jsObjectFromDartObjectTarget = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsObjectFromDartObject'), |
| jsValueBoxTarget = |
| coreTypes.index.getProcedure('dart:_js_helper', 'JSValue', 'box'), |
| jsValueClass = coreTypes.index.getClass('dart:_js_helper', 'JSValue'), |
| jsValueUnboxTarget = |
| coreTypes.index.getProcedure('dart:_js_helper', 'JSValue', 'unbox'), |
| wasmExternRefClass = |
| coreTypes.index.getClass('dart:_wasm', 'WasmExternRef'), |
| wasmExternRefNullRef = coreTypes.index |
| .getMember('dart:_wasm', 'WasmExternRef', 'get:nullRef'), |
| wasmArrayClass = coreTypes.index.getClass('dart:_wasm', 'WasmArray'), |
| wasmArrayRefClass = |
| coreTypes.index.getClass('dart:_wasm', 'WasmArrayRef'), |
| wasmI32Class = coreTypes.index.getClass('dart:_wasm', 'WasmI32'), |
| wasmI32ToIntSigned = coreTypes.index |
| .getProcedure('dart:_wasm', 'WasmI32', 'toIntSigned'), |
| wrapDartFunctionTarget = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', '_wrapDartFunction'), |
| exportWasmFunctionTarget = coreTypes.index |
| .getTopLevelProcedure('dart:_internal', 'exportWasmFunction'), |
| toJSBoolean = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'toJSBoolean'), |
| jsifyInt = |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'jsifyInt'), |
| toJSNumber = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'toJSNumber'), |
| jsifyNum = |
| coreTypes.index.getTopLevelProcedure('dart:_js_helper', 'jsifyNum'), |
| jsifyJSValue = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSValue'), |
| jsifyString = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyString'), |
| jsifyJSInt8ArrayImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSInt8ArrayImpl'), |
| jsifyJSUint8ArrayImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSUint8ArrayImpl'), |
| jsifyJSUint8ClampedArrayImpl = coreTypes.index.getTopLevelProcedure( |
| 'dart:_js_helper', 'jsifyJSUint8ClampedArrayImpl'), |
| jsifyJSInt16ArrayImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSInt16ArrayImpl'), |
| jsifyJSUint16ArrayImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSUint16ArrayImpl'), |
| jsifyJSInt32ArrayImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSInt32ArrayImpl'), |
| jsifyJSUint32ArrayImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSUint32ArrayImpl'), |
| jsifyJSFloat32ArrayImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSFloat32ArrayImpl'), |
| jsifyJSFloat64ArrayImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSFloat64ArrayImpl'), |
| jsInt8ArrayFromDartInt8List = coreTypes.index.getTopLevelProcedure( |
| 'dart:_js_helper', 'jsInt8ArrayFromDartInt8List'), |
| jsUint8ArrayFromDartUint8List = coreTypes.index.getTopLevelProcedure( |
| 'dart:_js_helper', 'jsUint8ArrayFromDartUint8List'), |
| jsUint8ClampedArrayFromDartUint8ClampedList = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', |
| 'jsUint8ClampedArrayFromDartUint8ClampedList'), |
| jsInt16ArrayFromDartInt16List = coreTypes.index.getTopLevelProcedure( |
| 'dart:_js_helper', 'jsInt16ArrayFromDartInt16List'), |
| jsUint16ArrayFromDartUint16List = coreTypes.index.getTopLevelProcedure( |
| 'dart:_js_helper', 'jsUint16ArrayFromDartUint16List'), |
| jsInt32ArrayFromDartInt32List = coreTypes.index.getTopLevelProcedure( |
| 'dart:_js_helper', 'jsInt32ArrayFromDartInt32List'), |
| jsUint32ArrayFromDartUint32List = coreTypes.index.getTopLevelProcedure( |
| 'dart:_js_helper', 'jsUint32ArrayFromDartUint32List'), |
| jsFloat32ArrayFromDartFloat32List = coreTypes.index |
| .getTopLevelProcedure( |
| 'dart:_js_helper', 'jsFloat32ArrayFromDartFloat32List'), |
| jsFloat64ArrayFromDartFloat64List = coreTypes.index |
| .getTopLevelProcedure( |
| 'dart:_js_helper', 'jsFloat64ArrayFromDartFloat64List'), |
| jsifyJSDataViewImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSDataViewImpl'), |
| jsifyByteData = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyByteData'), |
| jsifyRawList = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', '_jsifyRawList'), |
| jsifyJSArrayBufferImpl = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyJSArrayBufferImpl'), |
| jsArrayBufferFromDartByteBuffer = coreTypes.index.getTopLevelProcedure( |
| 'dart:_js_helper', 'jsArrayBufferFromDartByteBuffer'), |
| jsifyFunction = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'jsifyFunction'), |
| jsInt8ArrayImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSInt8ArrayImpl'), |
| jsUint8ArrayImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSUint8ArrayImpl'), |
| jsUint8ClampedArrayImplClass = coreTypes.index |
| .getClass('dart:_js_types', 'JSUint8ClampedArrayImpl'), |
| jsInt16ArrayImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSInt16ArrayImpl'), |
| jsUint16ArrayImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSUint16ArrayImpl'), |
| jsInt32ArrayImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSInt32ArrayImpl'), |
| jsUint32ArrayImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSUint32ArrayImpl'), |
| jsFloat32ArrayImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSFloat32ArrayImpl'), |
| jsFloat64ArrayImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSFloat64ArrayImpl'), |
| int8ListClass = coreTypes.index.getClass('dart:typed_data', 'Int8List'), |
| uint8ListClass = |
| coreTypes.index.getClass('dart:typed_data', 'Uint8List'), |
| uint8ClampedListClass = |
| coreTypes.index.getClass('dart:typed_data', 'Uint8ClampedList'), |
| int16ListClass = |
| coreTypes.index.getClass('dart:typed_data', 'Int16List'), |
| uint16ListClass = |
| coreTypes.index.getClass('dart:typed_data', 'Uint16List'), |
| int32ListClass = |
| coreTypes.index.getClass('dart:typed_data', 'Int32List'), |
| uint32ListClass = |
| coreTypes.index.getClass('dart:typed_data', 'Uint32List'), |
| float32ListClass = |
| coreTypes.index.getClass('dart:typed_data', 'Float32List'), |
| float64ListClass = |
| coreTypes.index.getClass('dart:typed_data', 'Float64List'), |
| jsDataViewImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSDataViewImpl'), |
| byteDataClass = coreTypes.index.getClass('dart:typed_data', 'ByteData'), |
| byteBufferClass = |
| coreTypes.index.getClass('dart:typed_data', 'ByteBuffer'), |
| jsArrayBufferImplClass = |
| coreTypes.index.getClass('dart:_js_types', 'JSArrayBufferImpl'), |
| isDartNullTarget = coreTypes.index |
| .getTopLevelProcedure('dart:_js_helper', 'isDartNull'), |
| throwArgumentNullErrorTarget = coreTypes.index.getTopLevelProcedure( |
| 'dart:_error_utils', '_throwArgumentNullError'); |
| |
| DartType get nonNullableObjectType => |
| coreTypes.objectRawType(Nullability.nonNullable); |
| |
| DartType get nonNullableWasmExternRefType => |
| wasmExternRefClass.getThisType(coreTypes, Nullability.nonNullable); |
| |
| DartType get nullableJSValueType => |
| InterfaceType(jsValueClass, Nullability.nullable); |
| |
| DartType get nullableWasmExternRefType => |
| wasmExternRefClass.getThisType(coreTypes, Nullability.nullable); |
| |
| /// Whether [type] erases to a `JSValue` or `JSValue?`. |
| bool isJSValueType(DartType type) => |
| extensionIndex.isStaticInteropType(type) || |
| extensionIndex.isExternalDartReferenceType(type); |
| |
| void annotateProcedure( |
| Procedure procedure, String pragmaOptionString, AnnotationType type) { |
| String pragmaNameType = switch (type) { |
| AnnotationType.import => 'import', |
| AnnotationType.export => 'export', |
| AnnotationType.weakExport => 'weak-export', |
| }; |
| procedure.addAnnotation(ConstantExpression( |
| InstanceConstant(coreTypes.pragmaClass.reference, [], { |
| coreTypes.pragmaName.fieldReference: |
| StringConstant('wasm:$pragmaNameType'), |
| coreTypes.pragmaOptions.fieldReference: StringConstant(pragmaOptionString) |
| }))); |
| } |
| |
| Expression variableCheckConstant( |
| VariableDeclaration variable, Constant constant) => |
| StaticInvocation(coreTypes.identicalProcedure, |
| Arguments([VariableGet(variable), ConstantExpression(constant)])); |
| |
| Expression variableGreaterThanOrEqualToConstant( |
| VariableDeclaration variable, Constant constant) => |
| InstanceInvocation( |
| InstanceAccessKind.Instance, |
| VariableGet(variable), |
| greaterThanOrEqualToTarget.name, |
| Arguments([ConstantExpression(constant)]), |
| interfaceTarget: greaterThanOrEqualToTarget, |
| functionType: greaterThanOrEqualToTarget.getterType as FunctionType, |
| ); |
| |
| /// Cast the [invocation] if needed to conform to the expected [expectedType]. |
| Expression castInvocationForReturn( |
| Expression invocation, DartType expectedType) { |
| Expression expression; |
| if (expectedType is VoidType) { |
| // Technically a `void` return value can still be used, by casting the |
| // return type to `dynamic` or `Object?`. However this case should be |
| // extremely rare, and `dartifyRaw` overhead for return values that should |
| // never be used in practice is too much, so we avoid `dartifyRaw` on |
| // `void` returns and always return `null`. |
| return BlockExpression( |
| Block([ExpressionStatement(invocation)]), NullLiteral()); |
| } |
| |
| if (isJSValueType(expectedType)) { |
| // TODO(joshualitt): Expose boxed `JSNull` and `JSUndefined` to Dart |
| // code after migrating existing users of js interop on Dart2Wasm. |
| // expression = _createJSValue(invocation); |
| // Casts are expensive, so we stick to a null-assertion if needed. If |
| // the nullability can't be determined, cast. |
| expression = invokeOneArg(jsValueBoxTarget, invocation); |
| final nullability = expectedType.extensionTypeErasure.nullability; |
| if (nullability == Nullability.nonNullable) { |
| expression = NullCheck(expression); |
| } else if (nullability == Nullability.undetermined) { |
| expression = AsExpression(expression, expectedType); |
| } |
| } else { |
| final expectedTypeExtensionTypeErasure = |
| expectedType.extensionTypeErasure; |
| final expectNullable = |
| expectedTypeExtensionTypeErasure.isPotentiallyNullable; |
| final conversionProcedure = |
| _dartConversionProcedure(expectedTypeExtensionTypeErasure); |
| final invocationValueVar = VariableDeclaration('#jsInvocation', |
| initializer: invocation, |
| type: nullableWasmExternRefType, |
| isSynthesized: true); |
| expression = Let( |
| invocationValueVar, |
| ConditionalExpression( |
| StaticInvocation( |
| isDartNullTarget, Arguments([VariableGet(invocationValueVar)])), |
| expectNullable |
| ? NullLiteral() |
| : StaticInvocation(throwArgumentNullErrorTarget, Arguments([])), |
| invokeOneArg(conversionProcedure, VariableGet(invocationValueVar)), |
| expectedType, |
| ), |
| ); |
| } |
| return expression; |
| } |
| |
| // Handles any necessary type conversions. Today this is just for handling the |
| // case where a user wants us to coerce a JS number to an int instead of a |
| // double. This is okay as long as the value is an integer value. |
| Expression convertAndCast(DartType staticType, Expression expression) { |
| final erasedType = staticType.extensionTypeErasure; |
| if (erasedType == coreTypes.intNullableRawType || |
| erasedType == coreTypes.intNonNullableRawType) { |
| // let v = [expression] as double? in |
| // if (v == null) { |
| // return null; |
| // } else { |
| // let v2 = v.toInt() in |
| // if (v == v2) { |
| // return v2; |
| // } else { |
| // throw; |
| // } |
| VariableDeclaration v = VariableDeclaration('#vardouble', |
| initializer: |
| AsExpression(expression, coreTypes.doubleNullableRawType), |
| type: coreTypes.doubleNullableRawType, |
| isSynthesized: true); |
| VariableDeclaration v2 = VariableDeclaration('#varint', |
| initializer: invokeMethod(v, numToIntTarget), |
| type: coreTypes.intNonNullableRawType, |
| isSynthesized: true); |
| expression = Let( |
| v, |
| ConditionalExpression( |
| variableCheckConstant(v, NullConstant()), |
| ConstantExpression(NullConstant()), |
| Let( |
| v2, |
| ConditionalExpression( |
| invokeMethod(v, coreTypes.objectEquals, |
| Arguments([VariableGet(v2)])), |
| VariableGet(v2), |
| Throw(StringLiteral( |
| 'Expected integer value, but was not integer.')), |
| coreTypes.intNonNullableRawType)), |
| coreTypes.intNullableRawType)); |
| } |
| return AsExpression(expression, staticType); |
| } |
| |
| /// Return the function to convert a value with type [valueType] to Dart |
| /// interop type [expectedType]. |
| /// |
| /// [expectedType] can be any interop type, but for now this only handles the |
| /// interop types generated by [_Specializer._getRawInteropProcedure]. |
| /// |
| /// `null` return value means no conversion is needed, the value can be passed |
| /// to the interop function directly. |
| /// |
| /// The argument passed to the returned conversion function needs to be |
| /// non-nullable. This function does not check the nullability of [valueType] |
| /// and assume that the argument passed to the conversion function won't be |
| /// `null`. |
| Procedure? _jsConversionProcedure( |
| DartType valueType, DartType expectedType, TypeEnvironment typeEnv) { |
| if (expectedType == coreTypes.doubleNonNullableRawType) { |
| assert(valueType is InterfaceType && |
| valueType.classNode == coreTypes.doubleClass); |
| return null; |
| } |
| |
| assert(expectedType == nullableWasmExternRefType, |
| 'Unexpected expected type: $expectedType'); |
| |
| for (final entry in _jsifyMap.entries) { |
| if (typeEnv.isSubtypeOf( |
| valueType, InterfaceType(entry.key, Nullability.nonNullable))) { |
| return entry.value; |
| } |
| } |
| |
| // `dynamic` or `Object?`, convert based on runtime type. |
| return jsifyRawTarget; |
| } |
| |
| /// Return the function to convert a value returned by an interop procedure |
| /// generated by [_Specializer.getRawInteropProcedure] to the expected Dart |
| /// type. |
| /// |
| /// The value passed to the returned conversion function should be an |
| /// `externref` and should be tested for `null` and `undefined`. The returned |
| /// procedures do not handle `null`s and `undefined`s. |
| Procedure _dartConversionProcedure(DartType expectedType) { |
| Procedure? conversionProcedure; |
| if (expectedType is InterfaceType) { |
| conversionProcedure = _dartifyMap[expectedType.classNode]; |
| } |
| return conversionProcedure ?? dartifyRawTarget; |
| } |
| } |
| |
| StaticInvocation invokeOneArg(Procedure target, Expression arg) => |
| StaticInvocation(target, Arguments([arg])); |
| |
| InstanceInvocation invokeMethod(VariableDeclaration receiver, Procedure target, |
| [Arguments? arguments]) => |
| InstanceInvocation(InstanceAccessKind.Instance, VariableGet(receiver), |
| target.name, arguments ?? Arguments([]), |
| interfaceTarget: target, |
| functionType: |
| target.function.computeFunctionType(Nullability.nonNullable)); |
| |
| bool parametersNeedParens(List<String> parameters) => |
| parameters.isEmpty || parameters.length > 1; |
| |
| Expression jsifyValue(VariableDeclaration variable, DartType expectedType, |
| CoreTypesUtil coreTypes, TypeEnvironment typeEnv) { |
| final Procedure? conversionProcedure; |
| |
| if (coreTypes.extensionIndex.isStaticInteropType(variable.type) || |
| coreTypes.extensionIndex.isExternalDartReferenceType(variable.type)) { |
| conversionProcedure = coreTypes.jsValueUnboxTarget; |
| } else { |
| conversionProcedure = |
| coreTypes._jsConversionProcedure(variable.type, expectedType, typeEnv); |
| } |
| |
| final conversion = conversionProcedure == null |
| ? VariableGet(variable) |
| : StaticInvocation( |
| conversionProcedure, Arguments([VariableGet(variable)])); |
| |
| if (variable.type.isPotentiallyNullable) { |
| return ConditionalExpression( |
| EqualsNull(VariableGet(variable)), |
| StaticGet(coreTypes.wasmExternRefNullRef), |
| conversion, |
| InterfaceType(coreTypes.wasmExternRefClass, Nullability.nullable)); |
| } else { |
| return conversion; |
| } |
| } |
