# But independently from this option we use default exclude patterns,
  # it can be disabled by `exclude-use-default: false`. To list all
  # excluded by default patterns execute `golangci-lint run --help`
  exclude:
    - composite literal uses unkeyed fields
  # Which dirs to exclude: issues from them won't be reported.
  # Can use regexp here: `generated.*`, regexp is applied on full path,
  # including the path prefix if one is set.

	return r
}

// VersionPurgeStatus returns a composite version purge status across targets
func (d *DeletedObject) VersionPurgeStatus() VersionPurgeStatusType {
	return d.ReplicationState.CompositeVersionPurgeStatus()
}

// DeleteMarkerReplicationStatus return composite replication status of delete marker across targets

 * 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.
 */

package org.gradle.integtests.composite.plugins

import org.gradle.integtests.fixtures.resolve.ResolveFailureTestFixture

class PluginBuildsIntegrationTest extends AbstractPluginBuildIntegrationTest {

  // inference.
  pm.addPass(mlir::TF::CreateGuaranteeAllFuncsOneUsePass());
  pm.addPass(mlir::TF::CreateTFShapeInferencePass());
  // Encapsulate PartitionedCall ops within a cluster so that the composite
  // resource ops can be decomposed.
  pm.addPass(tensorflow::tf2xla::internal::CreateXlaClusterFormationPass());
  // Running canonicalizer before decomposing resource ops in cluster helps the

			}
			continue
		}
		t1 := time.Now()
		evalResult, evalDetails, err := compilationResult.Program.ContextEval(ctx, va)
		// budget may be spent due to lazy evaluation of composited variables
		if compositionCtx != nil {
			compositionCost := compositionCtx.GetAndResetCost()
			if compositionCost > remainingBudget {
				return nil, -1, &cel.Error{
					Type:   cel.ErrorTypeInvalid,

    }

    def 'no extra executions for composite builds'() {
        // This test does two things:
        // - shake out internal listener registration that isn't using InternalListener.
        //   There are a lost of listeners registered through the methods that we've decorated in the composite build code
        // - sanity check application ids for the multi-build case
        given:

                        break;
                    }
                }
            }

            if (!actions.isEmpty()) {
                return Actions.composite(actions);
            }

            throw new UnsupportedOperationException("No action factory for specified command-line arguments.");
        }
    }

    /**

    bool is_read = read_array.contains(arg.getOperandNumber());
    bool is_update = update_array.contains(arg.getOperandNumber());
    // We want the resource operands that are on composite devices to be the
    // exact same set as the resource operands that are read or updated.
    if ((is_read || is_update) != lattice.is_on_composite_device) {
      return false;
    }
  }
  return true;
}

				pass.ReportRangef(x, "variable declaration copies lock value to %v: %v", valueSpec.Names[i].Name, path)
			}
		}
	}
}

// checkCopyLocksCompositeLit detects lock copy inside a composite literal
func checkCopyLocksCompositeLit(pass *analysis.Pass, cl *ast.CompositeLit) {
	for _, x := range cl.Elts {
		if node, ok := x.(*ast.KeyValueExpr); ok {
			x = node.Value
		}

WARNING: In <<composite_builds.adoc#composite_build_intro,composite builds>>, the rule that you have to match the exact requested dependency attributes is not applied: when using composites, Gradle will automatically match the requested attributes.