ℹ️ (flutter app utilizing android studio on MacBook)

Labored 2 days in the past on my flutter app with out points. In the present day I up to date my MacOS to fifteen.4 which I am guessing up to date Xcode to a more recent model as properly. On the primary construct of the app with out updating any packages (pub OR pod) it failed with the beneath code:

Parse Concern (Xcode): A template argument checklist is anticipated after a reputation prefixed by the template key phrase
(root)/ios/Pods/gRPC-Core/src/core/lib/promise/element/basic_seq.h:102:37

That is inflicting the app to not construct in any respect and will not in fact load.

⚠️ I’ve tried:

• Flutter clear construct, pod deintegrate, pod cache clear, Xcode clear construct folder.
• I’ve checked out that file the place it is complaining and may’t resolve the problem within the file manually with out inflicting extra errors. I’ve seen virtually related points with one thing referred to as ‘llvm‘ however not precisely the identical.

📋 Steps to breed:

Have a flutter mission on MacOS 15.4 with the suitable Xcode model, iOS Simulator operating both model 18.3 or 18.4, attempt to construct the app.

📁 My information:

Podfile:

platform :ios, '16.0'

# CocoaPods analytics sends community stats synchronously affecting flutter construct latency.
ENV['COCOAPODS_DISABLE_STATS'] = 'true'

mission 'Runner', {
  'Debug' => :debug,
  'Profile' => :launch,
  'Launch' => :launch,
}

def flutter_root
  generated_xcode_build_settings_path = File.expand_path(File.be part of('..', 'Flutter', 'Generated.xcconfig'), __FILE__)
  except File.exist?(generated_xcode_build_settings_path)
    increase "#{generated_xcode_build_settings_path} should exist. Should you're operating pod set up manually, be certain that flutter pub get is executed first"
  finish

  File.foreach(generated_xcode_build_settings_path) do |line|
    matches = line.match(/FLUTTER_ROOT=(.*)/)
    return matches[1].strip if matches
  finish
  increase "FLUTTER_ROOT not present in #{generated_xcode_build_settings_path}. Strive deleting Generated.xcconfig, then run flutter pub get"
finish

require File.expand_path(File.be part of('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root)

flutter_ios_podfile_setup

goal 'Runner' do
  use_frameworks!
  use_modular_headers!

  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
  goal 'RunnerTests' do
    inherit! :search_paths
  finish
finish

post_install do |installer|
  # This removes the warning about script phases
  installer.pods_project.build_configurations.every do |config|
    config.build_settings['CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES'] = 'YES'
  finish

  installer.pods_project.targets.every do |goal|
    # New BoringSSL-GRPC compiler flags repair
    if goal.identify == 'BoringSSL-GRPC'
      goal.source_build_phase.information.every do |file|
        if file.settings && file.settings['COMPILER_FLAGS']
          flags = file.settings['COMPILER_FLAGS'].break up
          flags.reject!  flag == '-GCC_WARN_INHIBIT_ALL_WARNINGS' 
          file.settings['COMPILER_FLAGS'] = flags.be part of(' ')
        finish
      finish
    finish

    flutter_additional_ios_build_settings(goal)

    # This disables the script part warnings
    goal.build_phases.every do |build_phase|
      if build_phase.respond_to?(:identify) && build_phase.identify.start_with?("Create Symlinks")
        build_phase.always_out_of_date = "1"
      finish
    finish

    goal.build_configurations.every do |config|
      config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '16.0'
      config.build_settings['ENABLE_BITCODE'] = 'NO'
      config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'NO'

      # Repair for BoringSSL-GRPC
      if goal.identify == 'BoringSSL-GRPC'
        config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||="$(inherited)"
        config.build_settings['OTHER_CFLAGS'] = '$(inherited) -fno-inline'
        config.build_settings.delete('OTHER_CFLAGS') if config.build_settings['OTHER_CFLAGS']&.embody?('-G')
      finish

      # Repair for Xcode 15 framework points
      config.build_settings['FRAMEWORK_SEARCH_PATHS'] ||= ['$(inherited)']
      config.build_settings['FRAMEWORK_SEARCH_PATHS'] << '${PODS_CONFIGURATION_BUILD_DIR}'

      config.build_settings['DEFINES_MODULE'] = 'YES'
      config.build_settings['SWIFT_VERSION'] = '5.0'

      # Add permission configurations
            config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
              '$(inherited)',

              # Enable only the permissions we need
              'PERMISSION_PHOTOS=1',
              'PERMISSION_LOCATION_WHENINUSE=1',
              'PERMISSION_NOTIFICATIONS=1',

              # Explicitly disable all other permissions
              'PERMISSION_LOCATION=0',
              'PERMISSION_EVENTS=0',
              'PERMISSION_EVENTS_FULL_ACCESS=0',
              'PERMISSION_REMINDERS=0',
              'PERMISSION_CONTACTS=0',
              'PERMISSION_CAMERA=0',
              'PERMISSION_MICROPHONE=0',
              'PERMISSION_SPEECH_RECOGNIZER=0',
              'PERMISSION_MEDIA_LIBRARY=0',
              'PERMISSION_SENSORS=0',
              'PERMISSION_BLUETOOTH=0',
              'PERMISSION_APP_TRACKING_TRANSPARENCY=0',
              'PERMISSION_CRITICAL_ALERTS=0',
              'PERMISSION_ASSISTANT=0'
            ]
    finish
  finish
finish

Error file (basic_seq.h):

// Copyright 2021 gRPC authors.
//
// Licensed below the Apache License, Model 2.0 (the "License");
// it's possible you'll not use this file besides in compliance with the License.
// You might get hold of a duplicate of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Except required by relevant regulation or agreed to in writing, software program
// distributed below the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, both categorical or implied.
// See the License for the particular language governing permissions and
// limitations below the License.

#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
#outline GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H

#embody 

#embody "src/core/lib/gprpp/construct_destruct.h"
#embody "src/core/lib/promise/ballot.h"

namespace grpc_core {
namespace promise_detail {

// Fashions a sequence of unknown measurement
// At every component, the accumulator A and the present worth V is handed to some
// perform of sort IterTraits::Manufacturing facility as f(V, IterTraits::Argument); f is
// anticipated to return a promise that resolves to IterTraits::Wrapped.
template 
class BasicSeqIter {
 non-public:
  utilizing Traits = typename IterTraits::Traits;
  utilizing Iter = typename IterTraits::Iter;
  utilizing Manufacturing facility = typename IterTraits::Manufacturing facility;
  utilizing Argument = typename IterTraits::Argument;
  utilizing IterValue = typename IterTraits::IterValue;
  utilizing StateCreated = typename IterTraits::StateCreated;
  utilizing State = typename IterTraits::State;
  utilizing Wrapped = typename IterTraits::Wrapped;

 public:
  BasicSeqIter(Iter start, Iter finish, Manufacturing facility f, Argument arg)
      : cur_(start), end_(finish), f_(std::transfer(f)) {
    if (cur_ == end_) {
      Assemble(&result_, std::transfer(arg));
    } else {
      Assemble(&state_, f_(*cur_, std::transfer(arg)));
    }
  }

  ~BasicSeqIter() {
    if (cur_ == end_) {
      Destruct(&result_);
    } else {
      Destruct(&state_);
    }
  }

  BasicSeqIter(const BasicSeqIter& different) = delete;
  BasicSeqIter& operator=(const BasicSeqIter&) = delete;

  BasicSeqIter(BasicSeqIter&& different) noexcept
      : cur_(different.cur_), end_(different.end_), f_(std::transfer(different.f_)) {
    if (cur_ == end_) {
      Assemble(&result_, std::transfer(different.result_));
    } else {
      Assemble(&state_, std::transfer(different.state_));
    }
  }
  BasicSeqIter& operator=(BasicSeqIter&& different) noexcept {
    cur_ = different.cur_;
    end_ = different.end_;
    if (cur_ == end_) {
      Assemble(&result_, std::transfer(different.result_));
    } else {
      Assemble(&state_, std::transfer(different.state_));
    }
    return *this;
  }

  Ballot operator()() {
    if (cur_ == end_) {
      return std::transfer(result_);
    }
    return PollNonEmpty();
  }

 non-public:
  Ballot PollNonEmpty() {
    Ballot r = state_();
    if (r.pending()) return r;
    return Traits::template CheckResultAndRunNext(
        std::transfer(r.worth()), [this](Wrapped arg) -> Ballot {
          auto subsequent = cur_;
          ++subsequent;
          if (subsequent == end_) {
            return std::transfer(arg);
          }
          cur_ = subsequent;
          state_.~State();
          Assemble(&state_,
                    Traits::template CallSeqFactory(f_, *cur_, std::transfer(arg)));
          return PollNonEmpty();
        });
  }

  Iter cur_;
  const Iter end_;
  GPR_NO_UNIQUE_ADDRESS Manufacturing facility f_;
  union {
    GPR_NO_UNIQUE_ADDRESS State state_;
    GPR_NO_UNIQUE_ADDRESS Argument result_;
  };
};

}  // namespace promise_detail
}  // namespace grpc_core

#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H