Implement host_flag? macro method, not affected by cross-compilation

src/compiler/crystal/macros.cr

@@ -36,6 +36,16 @@ module Crystal::Macros
   def flag?(name) : BoolLiteral
   end
 
+  # Returns whether a [compile-time flag](https://crystal-lang.org/docs/syntax_and_semantics/compile_time_flags.html)
+  # is set for the *host* platform, which can differ from the target platform
+  # (`flag?`) during cross-compilation.
+  #
+  # ```
+  # {{ host_flag?(:win32) }} # true or false
+  # ```
+  def host_flag?(name) : BoolLiteral
+  end
+
   # Prints AST nodes at compile-time. Useful for debugging macros.
   def puts(*expressions) : Nop
   end

src/compiler/crystal/macros/methods.cr

@@ -51,7 +51,7 @@ module Crystal
         interpret_debug(node)
       when "env"
         interpret_env(node)
-      when "flag?"
+      when "flag?", "host_flag?"
         interpret_flag?(node)
       when "puts"
         interpret_puts(node)
@@ -145,10 +145,18 @@ module Crystal
     def interpret_flag?(node)
       if node.args.size == 1
         node.args[0].accept self
-        flag = @last.to_macro_id
-        @last = BoolLiteral.new(@program.has_flag?(flag))
+        flag_name = @last.to_macro_id
+        flags = case node.name
+                when "flag?"
+                  @program.flags
+                when "host_flag?"
+                  @program.host_flags
+                else
+                  raise "Bug: unexpected macro method #{node.name}"
+                end
+        @last = BoolLiteral.new(flags.includes?(flag_name))
       else
-        node.wrong_number_of_arguments "macro call 'flag?'", node.args.size, 1
+        node.wrong_number_of_arguments "macro call '#{node.name}'", node.args.size, 1
       end
     end
 

src/compiler/crystal/semantic/flags.cr

@@ -1,5 +1,6 @@
 class Crystal::Program
   @flags : Set(String)?
+  @host_flags : Set(String)?
 
   # Returns the flags for this program. By default these
   # are computed from the target triple (for example x86_64,
@@ -11,6 +12,10 @@ class Crystal::Program
     @flags ||= flags_for_target(codegen_target)
   end
 
+  def host_flags
+    @host_flags ||= flags_for_target(Config.default_target)
+  end
+
   # Returns `true` if *name* is in the program's flags.
   def has_flag?(name : String)
     flags.includes?(name)
@@ -20,26 +25,26 @@ class Crystal::Program
     codegen_target.pointer_bit_width == 64
   end
 
-  private def flags_for_target(codegen_target)
+  private def flags_for_target(target)
     flags = Set(String).new
 
-    flags.add codegen_target.architecture
-    flags.add codegen_target.vendor
-    flags.concat codegen_target.environment_parts
+    flags.add target.architecture
+    flags.add target.vendor
+    flags.concat target.environment_parts
 
-    flags.add "bits#{codegen_target.pointer_bit_width}"
+    flags.add "bits#{target.pointer_bit_width}"
 
-    flags.add "armhf" if codegen_target.armhf?
+    flags.add "armhf" if target.armhf?
 
-    flags.add "unix" if codegen_target.unix?
-    flags.add "win32" if codegen_target.win32?
+    flags.add "unix" if target.unix?
+    flags.add "win32" if target.win32?
 
-    flags.add "darwin" if codegen_target.macos?
-    if codegen_target.freebsd?
+    flags.add "darwin" if target.macos?
+    if target.freebsd?
       flags.add "freebsd"
-      flags.add "freebsd#{codegen_target.freebsd_version}"
+      flags.add "freebsd#{target.freebsd_version}"
     end
-    flags.add "openbsd" if codegen_target.openbsd?
+    flags.add "openbsd" if target.openbsd?
 
     flags
   end