code: private void expectInterfaceProperty(
        Node n, ObjectType instance, ObjectType implementedInterface, String prop) {
      StaticTypedSlot propSlot = instance.getSlot(prop);
      if (propSlot == null) {
        // Not implemented
        String sourceName = n.getSourceFileName();
        sourceName = nullToEmpty(sourceName);
        registerMismatch(
            instance,
            implementedInterface,
            report(
                JSError.make(
                    n,
                    INTERFACE_METHOD_NOT_IMPLEMENTED,
                    prop,
                    implementedInterface.toString(),
                    instance.toString())));
      } else {
        Node propNode =
            propSlot.getDeclaration() == null ? null : propSlot.getDeclaration().getNode();
  
        // Fall back on the constructor node if we can't find a node for the
        // property.
        propNode = propNode == null ? n : propNode;
  
        JSType found = propSlot.getType();
        found = found.restrictByNotNullOrUndefined();
  
        JSType required
            = implementedInterface.getImplicitPrototype().getPropertyType(prop);
        TemplateTypeMap typeMap = implementedInterface.getTemplateTypeMap();
        if (!typeMap.isEmpty()) {
          TemplateTypeMapReplacer replacer = new TemplateTypeMapReplacer(
              typeRegistry, typeMap);
          required = required.visit(replacer);
        }
        required = required.restrictByNotNullOrUndefined();
  
        if (!found.isSubtype(required, this.subtypingMode)) {
          // Implemented, but not correctly typed
          FunctionType constructor =
              implementedInterface.toObjectType().getConstructor();
          JSError err =
              JSError.make(
                  propNode,
                  HIDDEN_INTERFACE_PROPERTY_MISMATCH,
                  prop,
                  instance.toString(),
                  constructor.getTopMostDefiningType(prop).toString(),
                  required.toString(),
                  found.toString());
          registerMismatch(found, required, err);
          report(err);
        }
      }
    }
docs: Expect that the property in an interface that this type implements is implemented and correctly
  typed.