toolchain | 🛠️ GitHub Action for ` rustup ` commands | Continous Integration library

Downgrading Xcode from 13.3 to 13.2.1 solved my problems.

This is an issue that occurs in version 13.3 of Xcode. In Xcode 13.3, if you have a code that uses UI_USER_INTERFACE_IDIOM(), you will get an "Out of Memory" error when you run Archive. Changing "UI_USER_INTERFACE_IDIOM()" to "UIDevice.current.userInterfaceIdiom" resolves the error.

Currently, we have the following solutions.

• Modify the code,
• Downgrade to Xcode 13.2.1
• Wait for Apple to modify Xcode

References

• https://developer.apple.com/forums/thread/702200
• https://bugs.swift.org/browse/SR-16003
• https://github.com/longitachi/ZLPhotoBrowser/issues/699

I had the same issue and solved it downgrading numpy to version 1.20.3 by:

I've actually had the same problem and came up with the following solution.

3rd Feb 2022 Update: The latest version of Flutter, version 2.10 stable, has this issue fixed along with stable desktop support for Windows.

Update: The flutter beta channel (2.9.0-0.1.pre onwards) comes with a fix.

According to this issue on the main flutter repo, Flutter prior to version 2.9 does not support Visual Studio 2022. If you want to build while targeting Windows you'll either have to install VS 2019 alongside 2022 or use this workaround:

The current workaround is : download your appropriate flutter version, edit _cmakeVisualStudioGeneratorIdentifier in https://github.com/flutter/flutter/blob/master/packages/flutter_tools/lib/src/windows/build_windows.dart#L25-L28 to your appropriate CMake Visual Studio Generator. You can get the currently available CMake Visual Studio Generators on this page : https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html#id13.

By default the _cmakeVisualStudioGeneratorIdentifier comes with CMake Visual Studio 2019 Generator. If you are going to use CMake Visual Studio 2022 Generator - firstly ensure your visual studio 2022 distribution contains Cmake 3.21 or later, refer https://cmake.org/cmake/help/latest/generator/Visual%20Studio%2017%202022.html for details.

To apply these changes on Windows:

• Edit path\to\flutter\packages\flutter_tools\lib\src\windows\build_windows.dart, and change the constant on line 28 from 'Visual Studio 16 2019' to 'Visual Studio 17 2022'
• Delete flutter_tools.stamp and flutter_tools.snapshot in path\to\flutter\bin\cache\ (to cause flutter to regenerate its build tools with the new source code you changed above)
• In the project path, run flutter clean to remove cached CMake files referring to the wrong Visual Studio version
• In the project path, run flutter run -d windows to restart the build (successfully, this time)

You have to manually install java on your PC but install the JRE(Java Runtime Environment) not the JDK (Java Development Kit). The JRE comes packed with all you'll need for flutter.

I think the one AS comes with is the JDK not the JRE

I have been facing this same issue for some time now. the same setup is working nicely in a mac with intel chip. But i have even done a resetup of my system, m1 mac still throws the same error.

I have solved it by forcing update flutter_math_fork adding to pubspec:

What exactly is going on with clang here?

TL;DR: Your Clang has a bug. You can probably work around it without modifying your code by adding -fno-common to your compile options.

Both variations of your code are correct, and as far as the C language specification is concerned, they have the same meaning. On my Linux machine, GCC 8.5 and Clang 12 both accept both variations and successfully build working executables, whether blah.o is linked directly or from a library.

But if you use nm to examine the library built with and without the initializer for p, you will likely get a hint about what is happening. Without an initializer, I see (with either compiler) that p has type 'C' (common). With an initializer (to null), I see that it has type 'B' (BSS).

That is reflective of a traditional behavior of Unix C implementations: to merge multiple definitions of the same symbol as long as no more than one is defined with an explicit initializer. That is an extension to standard C, for the language requires that there be exactly one definition of each external symbol that a program references. Among other things, that extension covers the common error of omitting extern from variable declarations in headers, provided that the header does not specify an initializer.

To implement that, the toolchain needs to distinguish between symbols defined with an explicit initializer and those defined without, and that's where (for C) symbol type "common" comes in -- it is used to convey a symbol that is defined, but without an explicit initializer. Typical linker behavior would be to treat all such symbols as undefined ones if one of the objects being linked has a definition for that symbol with a different type, or else to treat all but one of them as undefined, and the other as having type B (implying default initializtion).

But the MacOS development toolchain seems to have hatched a bug. In your example, it is erroneously failing to recognize the type C symbol as a viable definition when that appears in a library. The issue might be either in the Clang front end or in the system linker, or in a combination of both. Perhaps this arrived together with Apple's recent tightening (and subsequent re-loosening) of the compiler's default conformance settings.

You can probably work around this issue by adding --fno-common to your C compiler flags. GCC and Clang both accept that for disabling the symbol merging described above, and, at least on my machine, they both implement that by emitting the symbol as type B when it is defined without an explicit initializer, just as if it had been explicitly initialized to a null pointer. Note well, however, that this will break any code that is presently relying on that merging behavior.