name: "serialized"
          type: DT_STRING
        }
        input_arg {
          name: "names"
          type: DT_STRING
        }
        input_arg {
          name: "sparse_keys"
          type: DT_STRING
          number_attr: "Nsparse"
        }
        input_arg {
          name: "dense_keys"
          type: DT_STRING
          number_attr: "Ndense"
        }

        originBuildInvocationId(":t1") == null
        originBuildInvocationId(":t2") == scopeIds.buildInvocationIds[0].asString()

        when:
        update(i2, "2")

        then:
        succeeds("t")
        afterBuild()
        originBuildInvocationId(":t1") == scopeIds.buildInvocationIds[1].asString()
        originBuildInvocationId(":t2") == null

        and:
        with(scopeIds.workspaceIds) {

            return super.hashCode();
        }
        StringBuilder hashString = new StringBuilder(128);
        hashString.append(md.groupId).append('|');
        hashString.append(md.artifactId).append('|');

        if (compareVersion) {
            hashString.append(md.version).append('|');
        }

        if (compareScope) {
            hashString.append(md.getArtifactScope()).append('|');
        }

            classId.asString().replace('/', '.') to arrayClassId.asString().replace('/', '.')
        }
        StandardClassIds.unsignedArrayTypeByElementType.mapTo(this) { (classId, arrayClassId) ->
            classId.asString().replace('/', '.') to arrayClassId.asString().replace('/', '.')
        }
    }.toMap()

        JavaSourceQuery(
            false,
            object : PredicateVisitor() {
                override fun visit(declaration: MethodDeclaration, arg: Unit?): Boolean? {
                    if (declaration.name?.asString() == method.name && declaration.hasOverrideAnnotation) {
                        return true
                    }
                    return null
                }
            }
        )

	}
	for _, f := range p.Function {
		f.nameX = addString(strings, f.Name)
		f.systemNameX = addString(strings, f.SystemName)
		f.filenameX = addString(strings, f.Filename)
	}

	p.dropFramesX = addString(strings, p.DropFrames)
	p.keepFramesX = addString(strings, p.KeepFrames)

	if pt := p.PeriodType; pt != nil {
		pt.typeX = addString(strings, pt.Type)
		pt.unitX = addString(strings, pt.Unit)
	}

	p.commentX = nil

        return when (val symbolKind = symbolKind) {
            KaSymbolKind.LOCAL ->
                throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(classId?.asString() ?: name.asString())

            KaSymbolKind.CLASS_MEMBER, KaSymbolKind.TOP_LEVEL ->
                KaFirClassLikeSymbolPointer(classId!!, KaNamedClassOrObjectSymbol::class)

        "${declaringClass.baseQualifiedKotlinName}.${field.name}".let { fqn ->
            collectDescendantsOfType<KtProperty>()
                .firstOrNull { it.fqName?.asString() == fqn }
                ?.isDocumentedAsSince(version) == true
        }

    private
    fun KtFile.isDocumentedAsSince(version: String, declaringClass: CtClass, constructor: CtConstructor): Boolean {

            new AmbiguousBindingReporter.Provider("s1", methodDescriptor(AmbiguousBindingsInOneSource, "s1").toString()),
        ]).asString()

        cause.message == message
    }

    private ModelRuleDescriptor methodDescriptor(Class type, String methodName) {
        def declaringType = ModelType.of(type)

    }

    def "can roundtrip to / from string"() {
        when:
        def id = UniqueId.generate()
        def s = id.asString()

        then:
        UniqueId.from(s) == id
        UniqueId.from(s).asString() == s
    }