support c_shared mode

Summary:
Revival of D16782936: This add c_shared and c_archive mode which produces either .so or .a file instead of binary.

The code is ported to the modern buck.

Reviewed By: lebentle

fbshipit-source-id: fa0a4f7e3af8c2852e03bc827fc15901c6079246

Author: yottatsa

docs/__go_common.soy

@@ -137,7 +137,7 @@ Buck currently supports Go version 1.10.
   {param default: '[]' /}
   {param desc}
   Extra external linker flags passed to go link via <code>-extld</code> argument.
-  If argument is non-empty or <code>cgo_library</code> is used, the link mode 
+  If argument is non-empty or <code>cgo_library</code> is used, the link mode
   will switch to <code>external</code>.
   {/param}
 {/call}

docs/__table_of_contents.soy

@@ -76,6 +76,8 @@
             'go_library',
             'go_test',
             'cgo_library',
+            'go_exported_library',
+            'prebuilt_go_library',
         ],
         'groovy': [
             'groovy_library',

docs/rule/go_exported_library.soy

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+{namespace go_exported_library}
+
+/***/
+{template .soyweb}
+  {call buck.page}
+    {param title: 'go_exported_library()' /}
+    {param navid: 'rule_go_exported_library' /}
+    {param prettify: true /}
+    {param description}
+      A go_exported_library() rule builds a Go code into C shared or static library
+    {/param}
+    {param content}
+
+{call buck.rule}
+{param status: 'UNFROZEN' /}
+{param overview}
+<p>
+  A go_exported_library() rule builds a C library from the supplied set of Go source files
+  and dependencies. This is done via <code>-buildmode</code> flag and "//export" annotations in the code.
+</p>
+<p>
+  {call go_common.supported_language_version /}
+</p>
+{/param}
+
+{param args}
+
+{call buck.arg}
+  {param name: 'name' /}
+  {param desc}
+  The name of the rule.
+  {/param}
+{/call}
+
+{call go_common.srcs_arg /}
+
+{call go_common.deps_arg /}
+
+{call buck.arg}
+  {param name : 'build_mode' /}
+  {param desc}
+  Determines the build mode (equivalent of <code>-buildmode</code>). Can be
+  one of the following values: <code>c_archive</code>, <code>c_shared</code>.
+  This argument is valid only if at there is at least one <code>cgo_library</deps> declared in deps.
+  In addition you should make sure that <code>-shared</code> flag is added to <code>compiler_flags</code>
+  and go version under <code>go.goroot</code> is compiled with that flag present in:
+  <code>gcflags</code>, <code>ldflags</code> and <code>asmflags</code>
+  {/param}
+{/call}
+
+{call go_common.link_style_arg /}
+
+{call go_common.link_mode_arg /}
+
+{call go_common.compiler_flags_arg /}
+
+{call go_common.assembler_flags_arg /}
+
+{call go_common.linker_flags_arg /}
+
+{call go_common.external_linker_flags_arg /}
+
+{call buck.arg}
+  {param name: 'resources' /}
+  {param default : '[]' /}
+  {param desc}
+  Static files to be symlinked into the working directory of the test. You can access these in your
+  by opening the files as relative paths, e.g. <code>ioutil.ReadFile("testdata/input")</code>.
+  {/param}
+{/call}
+
+{/param} // close args
+
+{param examples}
+
+{call go_common.more_examples /}
+
+{literal}<pre class="prettyprint lang-py">
+go_exported_library(
+    name = "shared",
+    srcs = ["main.go"],
+    build_mode = "c_shared",
+    compiler_flags = ["-shared"],
+    deps = [":example"],
+)
+
+cgo_library(
+    name = "example",
+    package_name = "cgo",
+    srcs = [
+        "export-to-c.go",  # file with //export annotations
+    ],
+    cgo_compiler_flags = [],
+    compiler_flags = [],
+    headers = [],
+)
+
+cxx_genrule(
+    name = "cgo_exported_headers",
+    out = "includes",
+    cmd = (
+        "mkdir -p $OUT && " +
+        "cat `dirname $(location :shared)`/includes/*.h > $OUT/_cgo_export.h"
+    ),
+)
+
+prebuilt_cxx_library(
+    name = "cxx_so_with_header",
+    header_dirs = [":cgo_exported_headers"],
+    shared_lib = ":shared",
+)
+</pre>{/literal}
+{/param}
+
+{/call} // close buck.rule
+
+    {/param}
+  {/call}
+{/template}

src/com/facebook/buck/features/go/CGoLibrary.java

@@ -79,19 +79,25 @@
  */
 public class CGoLibrary extends NoopBuildRuleWithDeclaredAndExtraDeps {
   private final ImmutableList<SourcePath> goFiles;
+  private final Path packageName;
   private final SourcePath output;
+  private final SourcePath exportHeader;
   private final Iterable<BuildRule> linkableDeps;
 
   private CGoLibrary(
       BuildRuleParams params,
       BuildTarget buildTarget,
       ProjectFilesystem projectFilesystem,
       ImmutableList<SourcePath> goFiles,
+      Path packageName,
+      SourcePath exportHeader,
       SourcePath output,
       Iterable<BuildRule> linkableDeps) {
     super(buildTarget, projectFilesystem, params);
 
     this.goFiles = goFiles;
+    this.packageName = packageName;
+    this.exportHeader = exportHeader;
     this.output = output;
     this.linkableDeps = linkableDeps;
   }
@@ -102,6 +108,7 @@ public static BuildRule create(
       ProjectFilesystem projectFilesystem,
       ActionGraphBuilder graphBuilder,
       CellPathResolver cellRoots,
+      Path packageName,
       CxxBuckConfig cxxBuckConfig,
       DownwardApiConfig downwardApiConfig,
       GoPlatform platform,
@@ -328,6 +335,8 @@ public static BuildRule create(
                     .addAll(genSource.getGoFiles())
                     .add(Objects.requireNonNull(cgoImport.getSourcePathToOutput()))
                     .build(),
+                packageName,
+                Objects.requireNonNull(genSource.getExportHeader()),
                 Objects.requireNonNull(cgoAllBin.getSourcePathToOutput()),
                 Objects.requireNonNull(allDeps.get(graphBuilder, platform.getCxxPlatform()))));
   }
@@ -445,11 +454,21 @@ public ImmutableList<SourcePath> getGeneratedGoSource() {
     return goFiles;
   }
 
+  /** returns package name */
+  public Path getPackageName() {
+    return packageName;
+  }
+
   /** returns compiled linkable file source path */
   public SourcePath getOutput() {
     return output;
   }
 
+  /** returns _export.h file generated by gen-source step * */
+  public SourcePath getExportHeader() {
+    return exportHeader;
+  }
+
   public Iterable<BuildRule> getLinkableDeps() {
     return linkableDeps;
   }

src/com/facebook/buck/features/go/CgoLibraryDescription.java

@@ -51,6 +51,7 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Iterables;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.Optional;
@@ -174,6 +175,11 @@ public BuildRule createBuildRule(
               .map(BuildRule::getBuildTarget)
               .collect(ImmutableList.toImmutableList());
 
+      Path packageName =
+          args.getPackageName()
+              .map(Paths::get)
+              .orElse(goBuckConfig.getDefaultPackageName(buildTarget));
+
       BuildTarget cgoLibTarget = buildTarget.withAppendedFlavors(InternalFlavor.of("cgo"));
       CGoLibrary lib =
           (CGoLibrary)
@@ -183,6 +189,7 @@ public BuildRule createBuildRule(
                   projectFilesystem,
                   graphBuilder,
                   context.getCellPathResolver(),
+                  packageName,
                   cxxBuckConfig,
                   downwardApiConfig,
                   platform.get(),