anchor.diff:          final propertyHir = getPropertyDeclarationHir(queryContext, id);
           return hir.Identifier.property(
             id,
  -          propertyHir.type,
  +          bakeIfRequired(propertyHir.type),
             isMutable: propertyHir.isMutable,
             receiver: receiver,
           );
  
positive.code:           .toList(),
        returnType: functionHir.returnType.bakeGenerics(genericsMap),
      );
  
      if (!isValidExpressionType(functionHir.returnType)) {
        return Error([
  
negative.code:       DeclarationId id, [
        hir.Expression receiver,
      ]) {
        stderr.writeln('covertDeclarationId($id)');
  
        hir.CandyType bakeIfRequired(hir.CandyType type) {
          stderr.writeln('bakeIfRequired');
          stderr.writeln('declarationId = $declarationId');
          stderr.writeln('id = $id');
          stderr.writeln('type = $type');
  
          if (!declarationId.hasParent || !declarationId.parent.isImpl) {
            return type;
          }
  
          final impl = getImplDeclarationHir(queryContext, declarationId.parent);
          stderr.writeln('impl = $impl');
          final classId =
              moduleIdToDeclarationId(queryContext, impl.type.virtualModuleId);
          stderr.writeln('classId = $classId');
          if (id.parent.isNotClass || classId != id.parent) {
            // If the impl isn't exactly for the class, where the property is that
            // we want to convert, then just return its normal type.
            return type;
          }
          final class_ = getClassDeclarationHir(queryContext, classId);
          stderr.writeln('class = $class_');
  
          final typeParameters = class_.typeParameters
              .map((p) => CandyType.parameter(p.name, classId))
              .toList();
          final typeArguments = impl.typeParameters
              .map((it) => CandyType.parameter(it.name, declarationId.parent))
              .toList();
          final genericsMap = Map.fromEntries(
              typeParameters.zip<CandyType, MapEntry<CandyType, CandyType>>(
                  typeArguments, (a, b) => MapEntry(a, b)));
          stderr.writeln('genericsMap = $genericsMap');
          stderr.writeln('Baked type: ${type.bakeGenerics(genericsMap)}');
  
          return type.bakeGenerics(genericsMap);
        }
  
        if (id.isModule || id.isTrait || id.isClass) {
          return hir.Identifier.reflection(id);
        } else if (id.isFunction) {
          final functionHir = getFunctionDeclarationHir(queryContext, id);
          stderr.writeln(
              'Baked function type: ${bakeIfRequired(functionHir.functionType)}');
          return hir.Identifier.property(
            id,
            bakeIfRequired(functionHir.functionType),
            isMutable: false,
            receiver: receiver,
          );
  